package pe.edu.sistemas.sisdiam.controller;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.sql.Time;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.faces.model.SelectItem;

import org.primefaces.component.tabview.TabView;
import org.primefaces.context.RequestContext;
import org.primefaces.event.SelectEvent;
import org.primefaces.event.TabChangeEvent;
import org.primefaces.model.DefaultScheduleEvent;
import org.primefaces.model.DefaultScheduleModel;
import org.primefaces.model.ScheduleEvent;
import org.primefaces.model.ScheduleModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;

import com.sun.faces.context.InitParameterMap;

import pe.edu.sistemas.sisdiam.entities.Aula;
import pe.edu.sistemas.sisdiam.entities.Mailing;
import pe.edu.sistemas.sisdiam.entities.Periodo;
import pe.edu.sistemas.sisdiam.entities.Peticion;
import pe.edu.sistemas.sisdiam.entities.RegistroHorario;
import pe.edu.sistemas.sisdiam.entities.User;
import pe.edu.sistemas.sisdiam.repositories.PeriodoRepository;
import pe.edu.sistemas.sisdiam.services.AsignacionAulasService;
import pe.edu.sistemas.sisdiam.services.PeticionService;
import pe.edu.sistemas.sisdiam.services.ScheduleLaboService;
import pe.edu.sistemas.sisdiam.services.UserScheduleService;
import pe.edu.sistemas.sisdiam.util.Fecha;
import pe.edu.sistemas.sisdiam.util.ValidatorUtil;

/**
 * @author Francisco M
 *
 */
@Controller
@Scope("session")
public class LaboScheduleController {
	@Autowired
	UserScheduleService userService;
	@Autowired
	PeticionService peticionService;
	@Autowired
	ScheduleLaboService asignarAulas;
	@Autowired
	PeriodoRepository periodoRepository;
	@Autowired
	AsignacionAulasService asignarListaLaboratorios;
	// AsignacionAulasService asignarLaboratorios;
	private String nombreUsuario;
	private String aulaPedida;
	private String emailEncargado;
	private List<String> error2 = new ArrayList<String>();
	private int cruceFinal;
	private boolean denegadoDirecto = false;
	private Mailing mailer=new Mailing("NOTIFICACIONES.SISDIHO@gmail.com","@SISDIHOF1S1");
	private boolean mailaceptar = false;
	private boolean maildenegar = false;
	private int exCruce;
	private int cruPet;
	private int idPestañaActiva;
	private boolean existeCruce = false;
	private Peticion peticionDoc;
	private List<Peticion> listaPeticiones = new ArrayList<Peticion>();
	private List<Peticion> EventosAprobadosLabo = new ArrayList<Peticion>();
	private Date inicioCalendar;
	private Peticion peticionSelected;

	private String laboSeleccionado; // añadido 13.03.2015 By Angel
	private String laboInfoBreve; // añadido 13.03.2015 By Angel
	private String nombrePeriodoActual;	// añadido 15.03.2015 By Angel

	private List<RegistroHorario> listaLunes = new ArrayList<RegistroHorario>();
	private List<RegistroHorario> listaMartes = new ArrayList<RegistroHorario>();
	private List<RegistroHorario> listaMiercoles = new ArrayList<RegistroHorario>();
	private List<RegistroHorario> listaJueves = new ArrayList<RegistroHorario>();
	private List<RegistroHorario> listaViernes = new ArrayList<RegistroHorario>();
	private List<RegistroHorario> listaSabado = new ArrayList<RegistroHorario>();
	private List<RegistroHorario> listaDomingo = new ArrayList<RegistroHorario>();
	private List<Aula> listaLaboratorios = new ArrayList<Aula>();
	private List<RegistroHorario> horarioCruce = new ArrayList<RegistroHorario>();

	private ScheduleModel eventModel1;
	private ScheduleEvent eventSelected = new DefaultScheduleEvent();
	private DefaultScheduleEvent eventNuevo;
	private ScheduleModel eventModel2;
	private ScheduleModel eventModel3;
	private ScheduleModel eventModel4;
	private ScheduleModel eventModel5;
	private ScheduleModel eventModel6;
	private ScheduleModel eventModel7;
	private ScheduleModel eventModel8;
	private ScheduleModel eventModel9;
	private ScheduleModel eventModelA;
	private ScheduleModel eventModelB;
	private Periodo periodoActual = new Periodo();
	private Date fechaInicioP;
	private Date fechaFinP;
	private Date fechaAux;
	private User usuario;
	private List<Peticion> misPeticiones = new ArrayList<Peticion>();
	private RegistroHorario detalleClaseSelected;
	private Peticion detalleEventoSelected;
	private boolean detalleEvento;
	private boolean detalleClase;

	private boolean existeCrucePet = false;
	private boolean existeCruceClases = false;
	private boolean existeCruceEventos = false;
	private List<RegistroHorario> listaCruceHorarios = new ArrayList<RegistroHorario>();
	private List<Peticion> posibleCrucePet = new ArrayList<Peticion>();
	private List<Peticion> posibleCrucePetAprob = new ArrayList<Peticion>();
	private List<String> error = new ArrayList<String>();
	private List<Peticion> CrucePet = new ArrayList<Peticion>();
	private boolean soyUsuario;
	private int esUsuario;
	private List<Peticion> pendientes = new ArrayList<Peticion>();
	private List<String> idCEUPS;
	private List<String> idUPG;
	private int tipoEvento;
	private boolean esAlquiler;
	private int Alquiler;
	private String TipoE;

	private boolean mismoDia;
	private boolean fueraDeHora;
	private Date verdaderaFecha;
	private boolean dsblBtnEvaluar = false;

	private boolean camposVacios;
	
	/***************** 26-03 ******************/
	private Date horaMinimaInicio ;
	private Date horaMaximaInicio ;
	private Date horaMinimaFin ;
	/***************** 26-03 ******************/
	
	
	/***************** 29-03 ******************/
	private boolean nombreUsuarioVacio;
	/***************** 29-03 ******************/
	
	/*********************** Campos de validacion ****************/
	private boolean campoVacioOtraPersona;
	private boolean campoVacioNombreEvento;
	private boolean campoVacioEmail;
	private boolean campoEmailFormato;// valida si el campo email tiene el formato **@***.***
	private boolean campoVacioFecha;
	private boolean campoVacioHoraInicio;
	private boolean campoVacioHoraFin;
	private boolean campoVacioNumSemanas;
	private boolean campoVacioMotivo;
	private boolean noHayNumerosOtraPersona;
	/*********************** Campos de validacion ****************/
	private int capacidadLaboratorio;
	
	public LaboScheduleController() {
		nombreUsuarioVacio = false;
		verdaderaFecha = new Date();
		peticionDoc=new Peticion();
		inicioCalendar = new Date();
		peticionDoc.gethInicio().setMinutes(0);
		peticionDoc.gethFin().setMinutes(0);
		peticionDoc.gethInicio().setHours(verdaderaFecha.getHours()+1);
		System.out.println("============== Hora: "+verdaderaFecha.getHours()+1+" ======================");
		System.out.println("============== Hora: "+peticionDoc.gethInicio()+" ======================");

		peticionDoc.gethFin().setHours(22);
		
		horaMinimaInicio = sumarHoras(verdaderaFecha, 1);
		horaMaximaInicio = sumarHoras(peticionDoc.gethFin(), -1);
		horaMinimaFin = sumarHoras(peticionDoc.gethInicio(), 1);
		
		
		fueraDeHora();
		if (fueraDeHora) {
			peticionDoc.gethInicio().setHours(8);
			peticionDoc.gethInicio().setMinutes(0);
			peticionDoc.gethFin().setHours(22);
			peticionDoc.gethFin().setMinutes(0);
			inicioCalendar.setHours(8);
			inicioCalendar.setMinutes(0);
			if (inicioCalendar.getHours()>21 && inicioCalendar.getMinutes()>0) {
				inicioCalendar = sumarDiasFecha(peticionDoc.getDia(), 1);
				peticionDoc.setDia(sumarDiasFecha(peticionDoc.getDia(), 1));
			}
			
		}

	}

	
	
	
	@PostConstruct
	public void init() {
		Authentication auth;
		auth = SecurityContextHolder.getContext().getAuthentication();
		usuario = userService.obtenerUsuarioActual(auth.getName());
		// this.inicioCalendar=new Date();
		emailEncargado = peticionService.obtenerEmailLabo();
		nombreUsuario = peticionService.obtenerNombreUsuario(usuario
				.getId_persona());
		llenarLaboratorios();
		verificarTipoEvento();
		eventModel1 = new DefaultScheduleModel();
		eventModel2 = new DefaultScheduleModel();
		eventModel3 = new DefaultScheduleModel();
		eventModel4 = new DefaultScheduleModel();
		eventModel5 = new DefaultScheduleModel();
		eventModel6 = new DefaultScheduleModel();
		eventModel7 = new DefaultScheduleModel();
		eventModel8 = new DefaultScheduleModel();
		eventModel9 = new DefaultScheduleModel();
		eventModelA = new DefaultScheduleModel();
		eventModelB = new DefaultScheduleModel();
		llenartablapeticiones();
		llenarScheduleLabos();
		llenarScheduleEventos();
		llenarMisPeticiones();
		llenarEventosPendientes();
		obtenerNombrePeridoActual();
		// fueraDeHora();
		/********************** INICIA MODIFICACION: GPA-03 **********************/
		peticionDoc.setIdAulaPet(22);
		laboInfoBreve = "Numero: "
				+ listaLaboratorios.get((peticionDoc.getIdAulaPet() - 22))
						.getNomb()
				+ ", Capacidad: "
				+ listaLaboratorios.get((peticionDoc.getIdAulaPet() - 22))
						.getCapacidad();
		capacidadLaboratorio = listaLaboratorios.get((peticionDoc.getIdAulaPet()-22)).getCapacidad();
		/********************** TERMINA MODIFICACION: GPA-03 **********************/
	}

	public Date sumarDiasFecha(Date fecha, int dias) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha); // Configuramos la fecha que se recibe
		calendar.add(Calendar.DAY_OF_YEAR, dias); // numero de días a añadir, o
													// restar en caso de días<0
		return calendar.getTime(); // Devuelve el objeto Date con los nuevos
									// días añadidos
	}
	
	public Date sumarHoras(Date fecha, int horas) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha); // Configuramos la fecha que se recibe
		calendar.add(Calendar.HOUR_OF_DAY, horas); // numero de días a añadir, o
													// restar en caso de días<0
		return calendar.getTime(); // Devuelve el objeto Date con los nuevos
									// días añadidos
	}

	
	public void esDiaDeHoy() {
		Date fechah = inicioCalendar;
		String fechaHoy = fechah.getDate() + ":" + fechah.getMonth() + ":"
				+ fechah.getYear();
		System.out.println("fechaHoy:" + fechaHoy);
		Date fechap = peticionDoc.getDia();
		String fechaPeticion = fechap.getDate() + ":" + fechap.getMonth() + ":"
				+ fechap.getYear();
		System.out.println("fecha Peticion:" + fechaPeticion);
		mismoDia = fechaHoy.equals(fechaPeticion);
		if (mismoDia) {
			if(verdaderaFecha.getHours()<8){
				peticionDoc.gethInicio().setHours(8);
				peticionDoc.gethInicio().setMinutes(0);
			}
			/*else{
				System.out.println("========================Entro aqui:========================");
				//peticionDoc.gethInicio().setHours(verdaderaFecha.getHours()+1);
				System.out.println("========================================Entro aqui:" + peticionDoc.gethInicio().getHours());
			}*/
			
			peticionDoc.gethFin().setMinutes(0);
			
			horaMinimaInicio = sumarHoras(verdaderaFecha, 1);
			horaMaximaInicio = sumarHoras(peticionDoc.gethFin(), -1);
			horaMinimaFin = sumarHoras(peticionDoc.gethInicio(), 1);
			
			System.out.println("Hora minima inicio:" + horaMinimaInicio.getHours());
			System.out.println("Hora maxima inicio:" + horaMaximaInicio.getHours());
			System.out.println("Hora minima fin:" + horaMinimaFin.getHours());
			
		}
		else{
			
			horaMinimaInicio = sumarHoras(verdaderaFecha, 1);
			horaMaximaInicio = sumarHoras(peticionDoc.gethFin(), -1);
			horaMinimaFin = sumarHoras(peticionDoc.gethInicio(), 1);
			
			System.out.println("Hora minima inicio:" + horaMinimaInicio.getHours());
			System.out.println("Hora maxima inicio:" + horaMaximaInicio.getHours());
			System.out.println("Hora minima fin:" + horaMinimaFin.getHours());
		}
		System.out.println(mismoDia);
	}

	private void fueraDeHora(){
		fueraDeHora = inicioCalendar.getHours()<8 || (inicioCalendar.getHours()>21 && inicioCalendar.getMinutes()>0);
		System.out.println("Fuera de hora: "+fueraDeHora);
	}

	private boolean hayCamposVacios() {
		if(soyUsuario==false){
			campoVacioOtraPersona = (peticionDoc.getNombreUsuario().equalsIgnoreCase("") || peticionDoc.getNombreUsuario() == null?true:false);
		}else{
			campoVacioOtraPersona = false;
		}
		campoVacioNombreEvento = (peticionDoc.getNombreEvento().equalsIgnoreCase("") || peticionDoc.getNombreEvento() == null?true:false);
		campoVacioEmail = (peticionDoc.getEmail().equalsIgnoreCase("") ||peticionDoc.getEmail() == null?true:false);
		if (campoVacioOtraPersona) {
			noHayNumerosOtraPersona = false;
		} else {
			noHayNumerosOtraPersona = ValidatorUtil.validateAlphab(peticionDoc.getNombreUsuario());
		}
		
		
		if(campoVacioEmail){
			campoEmailFormato = false;
		}else{
			campoEmailFormato = ValidatorUtil.validateEmail(peticionDoc.getEmail());
		}
		campoVacioFecha = (peticionDoc.getDia() == null?true:false);
		campoVacioHoraInicio = (peticionDoc.gethInicio() == null?true:false);
		campoVacioHoraFin = (peticionDoc.gethFin() == null?true:false);
		campoVacioNumSemanas = (peticionDoc.getNumRep()<1?true:false);
		campoVacioMotivo = (peticionDoc.getMotivo().equals("") || peticionDoc.getMotivo()==null?true:false);
		
//		return ((mot== null || mot.isEmpty()? true:false) || (em== null || em.isEmpty()?true:false) || (ne == null || ne.isEmpty()?true:false) || nombreUsuarioVacio);
		return campoVacioOtraPersona || campoVacioNombreEvento || campoVacioEmail || campoVacioFecha || campoVacioHoraInicio || campoVacioHoraFin || campoVacioNumSemanas || campoVacioMotivo;
	}

	private boolean hayCamposVaciosAdmin() {
		if(soyUsuario==false){
			campoVacioOtraPersona = (peticionDoc.getNombreUsuario().equalsIgnoreCase("") || peticionDoc.getNombreUsuario() == null?true:false);
		}else{
			campoVacioOtraPersona = false;
		}
		campoVacioNombreEvento = (peticionDoc.getNombreEvento().equalsIgnoreCase("") || peticionDoc.getNombreEvento() == null?true:false);
		
		if (campoVacioOtraPersona) {
			noHayNumerosOtraPersona = false;
		} else {
			noHayNumerosOtraPersona = ValidatorUtil.validateAlphab(peticionDoc.getNombreUsuario());
		}
		
		System.out.println("==================Check marcado: "+soyUsuario);
		System.out.println("==================Hay numeros: "+!noHayNumerosOtraPersona);
		System.out.println(peticionDoc.getNombreUsuario());
		System.out.println(peticionDoc.getMotivo());
		
		
		campoVacioFecha = (peticionDoc.getDia() == null?true:false);
		campoVacioHoraInicio = (peticionDoc.gethInicio() == null?true:false);
		campoVacioHoraFin = (peticionDoc.gethFin() == null?true:false);
		campoVacioNumSemanas = (peticionDoc.getNumRep()<1?true:false);
		campoVacioMotivo = (peticionDoc.getMotivo().equals("") || peticionDoc.getMotivo()==null?true:false);
		
//		return ((mot== null || mot.isEmpty()? true:false) || (em== null || em.isEmpty()?true:false) || (ne == null || ne.isEmpty()?true:false) || nombreUsuarioVacio);
		return campoVacioOtraPersona || campoVacioNombreEvento || campoVacioFecha || campoVacioHoraInicio || campoVacioHoraFin || campoVacioNumSemanas || campoVacioMotivo;
	}
	
	
	public int getCapacidadLaboratorio() {
		return capacidadLaboratorio;
	}




	public void setCapacidadLaboratorio(int capacidadLaboratorio) {
		this.capacidadLaboratorio = capacidadLaboratorio;
	}




	public Date getHoraMinimaInicio() {
		return horaMinimaInicio;
	}




	public void setHoraMinimaInicio(Date horaMinimaInicio) {
		this.horaMinimaInicio = horaMinimaInicio;
	}




	public Date getHoraMaximaInicio() {
		return horaMaximaInicio;
	}




	public void setHoraMaximaInicio(Date horaMaximaInicio) {
		this.horaMaximaInicio = horaMaximaInicio;
	}




	public Date getHoraMinimaFin() {
		return horaMinimaFin;
	}




	public void setHoraMinimaFin(Date horaMinimaFin) {
		this.horaMinimaFin = horaMinimaFin;
	}
	
	

	public boolean isNoHayNumerosOtraPersona() {
		return noHayNumerosOtraPersona;
	}




	public void setNoHayNumerosOtraPersona(boolean noHayNumerosOtraPersona) {
		this.noHayNumerosOtraPersona = noHayNumerosOtraPersona;
	}




	public boolean isCamposVacios() {
		return camposVacios;
	}

	public void setCamposVacios(boolean camposVacios) {
		this.camposVacios = camposVacios;
	}

	public boolean isAntesHora() {
		return fueraDeHora;
	}

	public void setAntesHora(boolean antesHora) {
		this.fueraDeHora = antesHora;
	}

	public String getNombreUsuario() {
		return nombreUsuario;
	}

	public void setNombreUsuario(String nombreUsuario) {
		this.nombreUsuario = nombreUsuario;
	}

	public String getAulaPedida() {
		return aulaPedida;
	}

	public void setAulaPedida(String aulaPedida) {
		this.aulaPedida = aulaPedida;
	}

	public String getEmailEncargado() {
		return emailEncargado;
	}

	public void setEmailEncargado(String emailEncargado) {
		this.emailEncargado = emailEncargado;
	}

	public List<String> getError2() {
		return error2;
	}

	public void setError2(List<String> error2) {
		this.error2 = error2;
	}

	public int getCruceFinal() {
		return cruceFinal;
	}

	public void setCruceFinal(int cruceFinal) {
		this.cruceFinal = cruceFinal;
	}

	public boolean isEsAlquiler() {
		return esAlquiler;
	}

	public void setEsAlquiler(boolean esAlquiler) {
		this.esAlquiler = esAlquiler;
	}

	public int getAlquiler() {
		return Alquiler;
	}

	public void setAlquiler(int alquiler) {
		Alquiler = alquiler;
	}

	public String getTipoE() {
		return TipoE;
	}

	public void setTipoE(String tipoE) {
		TipoE = tipoE;
	}

	public int getTipoEvento() {
		return tipoEvento;
	}

	public void setTipoEvento(int tipoEvento) {
		this.tipoEvento = tipoEvento;
	}

	public List<String> getIdCEUPS() {
		return idCEUPS;
	}

	public void setIdCEUPS(List<String> idCEUPS) {
		this.idCEUPS = idCEUPS;
	}

	public List<String> getIdUPG() {
		return idUPG;
	}

	public void setIdUPG(List<String> idUPG) {
		this.idUPG = idUPG;
	}

	public List<Peticion> getPendientes() {
		return pendientes;
	}

	public void setPendientes(List<Peticion> pendientes) {
		this.pendientes = pendientes;
	}

	public boolean isDenegadoDirecto() {
		return denegadoDirecto;
	}

	public void setDenegadoDirecto(boolean denegadoDirecto) {
		this.denegadoDirecto = denegadoDirecto;
	}

	public Mailing getMailer() {
		return mailer;
	}

	public void setMailer(Mailing mailer) {
		this.mailer = mailer;
	}

	public boolean isMailaceptar() {
		return mailaceptar;
	}

	public void setMailaceptar(boolean mailaceptar) {
		this.mailaceptar = mailaceptar;
	}

	public boolean isMaildenegar() {
		return maildenegar;
	}

	public void setMaildenegar(boolean maildenegar) {
		this.maildenegar = maildenegar;
	}

	public int getExCruce() {
		return exCruce;
	}

	public void setExCruce(int exCruce) {
		this.exCruce = exCruce;
	}

	public int getCruPet() {
		return cruPet;
	}

	public void setCruPet(int cruPet) {
		this.cruPet = cruPet;
	}

	public int getEsUsuario() {
		return esUsuario;
	}

	public void setEsUsuario(int esUsuario) {
		this.esUsuario = esUsuario;
	}

	public boolean isSoyUsuario() {
		return soyUsuario;
	}

	public void setSoyUsuario(boolean soyUsuario) {
		this.soyUsuario = soyUsuario;
	}

	public List<Peticion> getPosibleCrucePetAprob() {
		return posibleCrucePetAprob;
	}

	public void setPosibleCrucePetAprob(List<Peticion> posibleCrucePetAprob) {
		this.posibleCrucePetAprob = posibleCrucePetAprob;
	}

	public List<RegistroHorario> getListaCruceHorarios() {
		return listaCruceHorarios;
	}

	public void setListaCruceHorarios(List<RegistroHorario> listaCruceHorarios) {
		this.listaCruceHorarios = listaCruceHorarios;
	}

	public List<Peticion> getCrucePet() {
		return CrucePet;
	}

	public void setCrucePet(List<Peticion> crucePet) {
		CrucePet = crucePet;
	}

	public List<String> getError() {
		return error;
	}

	public void setError(List<String> error) {
		this.error = error;
	}

	public List<Peticion> getPosibleCrucePet() {
		return posibleCrucePet;
	}

	public void setPosibleCrucePet(List<Peticion> posibleCrucePet) {
		this.posibleCrucePet = posibleCrucePet;
	}

	public boolean isExisteCrucePet() {
		return existeCrucePet;
	}

	public void setExisteCrucePet(boolean existeCrucePet) {
		this.existeCrucePet = existeCrucePet;
	}

	public boolean isExisteCruceClases() {
		return existeCruceClases;
	}

	public void setExisteCruceClases(boolean existeCruceClases) {
		this.existeCruceClases = existeCruceClases;
	}

	public boolean isExisteCruceEventos() {
		return existeCruceEventos;
	}

	public void setExisteCruceEventos(boolean existeCruceEventos) {
		this.existeCruceEventos = existeCruceEventos;
	}

	public User getUsuario() {
		return usuario;
	}

	public void setUsuario(User usuario) {
		this.usuario = usuario;
	}

	public boolean isDetalleEvento() {
		return detalleEvento;
	}

	public void setDetalleEvento(boolean detalleEvento) {
		this.detalleEvento = detalleEvento;
	}

	public boolean isDetalleClase() {
		return detalleClase;
	}

	public void setDetalleClase(boolean detalleClase) {
		this.detalleClase = detalleClase;
	}

	public RegistroHorario getDetalleClaseSelected() {
		return detalleClaseSelected;
	}

	public void setDetalleClaseSelected(RegistroHorario detalleClaseSelected) {
		this.detalleClaseSelected = detalleClaseSelected;
	}

	public Peticion getDetalleEventoSelected() {
		return detalleEventoSelected;
	}

	public void setDetalleEventoSelected(Peticion detalleEventoSelected) {
		this.detalleEventoSelected = detalleEventoSelected;
	}

	public ScheduleEvent getEventSelected() {
		return eventSelected;
	}

	public void setEventSelected(ScheduleEvent eventSelected) {
		this.eventSelected = eventSelected;
	}

	public DefaultScheduleEvent getEventNuevo() {
		return eventNuevo;
	}

	public void setEventNuevo(DefaultScheduleEvent eventNuevo) {
		this.eventNuevo = eventNuevo;
	}

	public ScheduleModel getEventModel2() {
		return eventModel2;
	}

	public void setEventModel2(ScheduleModel eventModel2) {
		this.eventModel2 = eventModel2;
	}

	public ScheduleModel getEventModel3() {
		return eventModel3;
	}

	public void setEventModel3(ScheduleModel eventModel3) {
		this.eventModel3 = eventModel3;
	}

	public ScheduleModel getEventModel4() {
		return eventModel4;
	}

	public void setEventModel4(ScheduleModel eventModel4) {
		this.eventModel4 = eventModel4;
	}

	public ScheduleModel getEventModel5() {
		return eventModel5;
	}

	public void setEventModel5(ScheduleModel eventModel5) {
		this.eventModel5 = eventModel5;
	}

	public ScheduleModel getEventModel6() {
		return eventModel6;
	}

	public void setEventModel6(ScheduleModel eventModel6) {
		this.eventModel6 = eventModel6;
	}

	public ScheduleModel getEventModel7() {
		return eventModel7;
	}

	public void setEventModel7(ScheduleModel eventModel7) {
		this.eventModel7 = eventModel7;
	}

	public ScheduleModel getEventModel8() {
		return eventModel8;
	}

	public void setEventModel8(ScheduleModel eventModel8) {
		this.eventModel8 = eventModel8;
	}

	public ScheduleModel getEventModelA() {
		return eventModelA;
	}

	public void setEventModelA(ScheduleModel eventModelA) {
		this.eventModelA = eventModelA;
	}

	public ScheduleModel getEventModelB() {
		return eventModelB;
	}

	public void setEventModelB(ScheduleModel eventModelB) {
		this.eventModelB = eventModelB;
	}

	public List<Peticion> getMisPeticiones() {
		return misPeticiones;
	}

	public void setMisPeticiones(List<Peticion> misPeticiones) {
		this.misPeticiones = misPeticiones;
	}

	public Peticion getPeticionSelected() {
		return peticionSelected;
	}

	public void setPeticionSelected(Peticion peticionSelected) {
		this.peticionSelected = peticionSelected;
	}

	public Date getInicioCalendar() {
		return inicioCalendar;
	}

	public void setInicioCalendar(Date inicioCalendar) {
		this.inicioCalendar = inicioCalendar;
	}

	public Peticion getPeticionDoc() {
		return peticionDoc;
	}

	public void setPeticionDoc(Peticion peticionDoc) {
		this.peticionDoc = peticionDoc;
	}

	public List<Peticion> getListaPeticiones() {
		return listaPeticiones;
	}

	public void setListaPeticiones(List<Peticion> listaPeticiones) {
		this.listaPeticiones = listaPeticiones;
	}

	public int getIdPestañaActiva() {
		return idPestañaActiva;
	}

	public void setIdPestañaActiva(int idPestañaActiva) {
		this.idPestañaActiva = idPestañaActiva;
	}

	public List<Aula> getListaLaboratorios() {
		return listaLaboratorios;
	}

	public void setListaLaboratorios(List<Aula> listaLaboratorios) {
		this.listaLaboratorios = listaLaboratorios;
	}

	public List<RegistroHorario> getHorarioCruce() {
		return horarioCruce;
	}

	public void setHorarioCruce(List<RegistroHorario> horarioCruce) {
		this.horarioCruce = horarioCruce;
	}

	public boolean isExisteCruce() {
		return existeCruce;
	}

	public void setExisteCruce(boolean existeCruce) {
		this.existeCruce = existeCruce;
	}

	public ScheduleModel getEventModel1() {
		return eventModel1;
	}

	public void setEventModel1(ScheduleModel eventModel1) {
		this.eventModel1 = eventModel1;
	}

	public ScheduleModel getEventModel9() {
		return eventModel9;
	}

	public void setEventModel9(ScheduleModel eventModel9) {
		this.eventModel9 = eventModel9;
	}

	/*
	 * public void actualizarAula(int idAulaSelected , RegistroHorario
	 * horarioSelected){ asignarAulas.actualizarAulas(idAulaSelected,
	 * horarioSelected); }
	 */

	public List<RegistroHorario> getListaLunes() {
		return listaLunes;
	}

	public void setListaLunes(List<RegistroHorario> listaLunes) {
		this.listaLunes = listaLunes;
	}

	public List<Peticion> getEventosAprobadosLabo() {
		return EventosAprobadosLabo;
	}

	public void setEventosAprobadosLabo(List<Peticion> eventosAprobadosLabo) {
		EventosAprobadosLabo = eventosAprobadosLabo;
	}

	public List<RegistroHorario> getListaMartes() {
		return listaMartes;
	}

	public void setListaMartes(List<RegistroHorario> listaMartes) {
		this.listaMartes = listaMartes;
	}

	public List<RegistroHorario> getListaMiercoles() {
		return listaMiercoles;
	}

	public void setListaMiercoles(List<RegistroHorario> listaMiercoles) {
		this.listaMiercoles = listaMiercoles;
	}

	public List<RegistroHorario> getListaJueves() {
		return listaJueves;
	}

	public void setListaJueves(List<RegistroHorario> listaJueves) {
		this.listaJueves = listaJueves;
	}

	public List<RegistroHorario> getListaViernes() {
		return listaViernes;
	}

	public void setListaViernes(List<RegistroHorario> listaViernes) {
		this.listaViernes = listaViernes;
	}

	public List<RegistroHorario> getListaSabado() {
		return listaSabado;
	}

	public void setListaSabado(List<RegistroHorario> listaSabado) {
		this.listaSabado = listaSabado;
	}

	public List<RegistroHorario> getListaDomingo() {
		return listaDomingo;
	}

	public void setListaDomingo(List<RegistroHorario> listaDomingo) {
		this.listaDomingo = listaDomingo;
	}

	public Periodo getPeriodoActual() {
		return periodoActual;
	}

	public void setPeriodoActual(Periodo periodoActual) {
		this.periodoActual = periodoActual;
	}

	public Date getFechaInicioP() {
		return fechaInicioP;
	}

	public void setFechaInicioP(Date fechaInicioP) {
		this.fechaInicioP = fechaInicioP;
	}

	public Date getFechaFinP() {
		return fechaFinP;
	}

	public void setFechaFinP(Date fechaFinP) {
		this.fechaFinP = fechaFinP;
	}

	public Date getFechaAux() {
		return fechaAux;
	}

	public void setFechaAux(Date fechaAux) {
		this.fechaAux = fechaAux;
	}

	/********************** INICIA MODIFICACION **********************/
	// añadido 14.03.2015
	public String getLaboInfoBreve() {
		return laboInfoBreve;
	}

	public void setLaboInfoBreve(String laboInfoBreve) {
		this.laboInfoBreve = laboInfoBreve;
	}

	public String getLaboSeleccionado() {
		return laboSeleccionado;
	}

	public void setLaboSeleccionado(String laboSeleccionado) {
		this.laboSeleccionado = laboSeleccionado;
	}
	// añadido 15.03.2015
	public String getNombrePeriodoActual() {
		return nombrePeriodoActual;
	}

	public void setNombrePeriodoActual(String nombrePeriodoActual) {
		this.nombrePeriodoActual = nombrePeriodoActual;
	}
	/********************** TERMINA MODIFICACION **********************/
	
	/******* MODIFICACION REALIZADA ****************************/
	public void limpiarCampos() {
		peticionDoc.limpiar();
		limpiar();
		llenartablapeticiones();
		llenarEventosPendientes();
		llenarScheduleEventos();
		llenarScheduleLabos();
	}

	/*************************************/

	public boolean isMismoDia() {
		return mismoDia;
	}

	public void setMismoDia(boolean mismoDia) {
		this.mismoDia = mismoDia;
	}

	public boolean isCampoVacioOtraPersona() {
		return campoVacioOtraPersona;
	}




	public void setCampoVacioOtraPersona(boolean campoVacioOtraPersona) {
		this.campoVacioOtraPersona = campoVacioOtraPersona;
	}




	public boolean isCampoVacioNombreEvento() {
		return campoVacioNombreEvento;
	}




	public void setCampoVacioNombreEvento(boolean campoVacioNombreEvento) {
		this.campoVacioNombreEvento = campoVacioNombreEvento;
	}




	public boolean isCampoVacioEmail() {
		return campoVacioEmail;
	}




	public void setCampoVacioEmail(boolean campoVacioEmail) {
		this.campoVacioEmail = campoVacioEmail;
	}




	public boolean isCampoVacioFecha() {
		return campoVacioFecha;
	}




	public void setCampoVacioFecha(boolean campoVacioFecha) {
		this.campoVacioFecha = campoVacioFecha;
	}




	public boolean isCampoVacioHoraInicio() {
		return campoVacioHoraInicio;
	}




	public void setCampoVacioHoraInicio(boolean campoVacioHoraInicio) {
		this.campoVacioHoraInicio = campoVacioHoraInicio;
	}




	public boolean isCampoVacioHoraFin() {
		return campoVacioHoraFin;
	}




	public void setCampoVacioHoraFin(boolean campoVacioHoraFin) {
		this.campoVacioHoraFin = campoVacioHoraFin;
	}




	public boolean isCampoVacioNumSemanas() {
		return campoVacioNumSemanas;
	}




	public void setCampoVacioNumSemanas(boolean campoVacioNumSemanas) {
		this.campoVacioNumSemanas = campoVacioNumSemanas;
	}




	public boolean isCampoVacioMotivo() {
		return campoVacioMotivo;
	}




	public void setCampoVacioMotivo(boolean campoVacioMotivo) {
		this.campoVacioMotivo = campoVacioMotivo;
	}




	public boolean isCampoEmailFormato() {
		return campoEmailFormato;
	}




	public void setCampoEmailFormato(boolean campoEmailFormato) {
		this.campoEmailFormato = campoEmailFormato;
	}




	public void limpiar() {
		listaPeticiones.clear();
		eventModel1.clear();
		eventModel2.clear();
		eventModel3.clear();
		eventModel4.clear();
		eventModel5.clear();
		eventModel6.clear();
		eventModel7.clear();
		eventModel8.clear();
		eventModel9.clear();
		eventModelA.clear();
		eventModelB.clear();
		misPeticiones.clear();
		peticionDoc.limpiar();
		setDetalleEvento(false);
		setDetalleClase(false);

		setCruPet(0);

	}

	public void onEventSelect(SelectEvent selectEvent) {
		eventSelected = (ScheduleEvent) selectEvent.getObject();
		if (eventSelected.getData() instanceof RegistroHorario) {
			detalleClaseSelected = (RegistroHorario) eventSelected.getData();
			setDetalleClase(true);
			setDetalleEvento(false);
		} else {
			detalleEventoSelected = (Peticion) eventSelected.getData();
			setDetalleClase(false);
			setDetalleEvento(true);
			System.out.println(detalleEventoSelected.getNombrePersona() + " "
					+ detalleEventoSelected.getNombreUsuario());
		}

	}

	/********************** INICIA MODIFICACION: GPA-03 **********************/
	public void onTabChange(TabChangeEvent event) {
		TabView tabView = (TabView) event.getComponent();
		idPestañaActiva = tabView.getChildren().indexOf(event.getTab());

		this.setLaboSeleccionado(event.getTab().getTitle());
		peticionDoc
				.setIdAulaPet(this.idLaboratorio(this.getLaboSeleccionado()));
		laboInfoBreve = "Numero: "
				+ listaLaboratorios.get((peticionDoc.getIdAulaPet() - 22))
						.getNomb()
				+ ", Capacidad: "
				+ listaLaboratorios.get((peticionDoc.getIdAulaPet() - 22))
						.getCapacidad();
		capacidadLaboratorio = listaLaboratorios.get((peticionDoc.getIdAulaPet()-22)).getCapacidad();
		System.out.println(peticionDoc.getIdAulaPet());
		System.out.println(laboInfoBreve);
	}

	// añadido 14.03.2015 By Angel
	public int idLaboratorio(String Nombre) {
		if (Nombre.equals("Laboratorio 1"))
			return 22;
		if (Nombre.equals("Laboratorio 2 - UPG"))
			return 23;
		if (Nombre.equals("Laboratorio 3"))
			return 24;
		if (Nombre.equals("Laboratorio 4"))
			return 25;
		if (Nombre.equals("Laboratorio 5"))
			return 26;
		if (Nombre.equals("Laboratorio 6"))
			return 27;
		if (Nombre.equals("Laboratorio 7 - UPG"))
			return 28;
		if (Nombre.equals("Laboratorio 8"))
			return 29;
		if (Nombre.equals("Laboratorio 9 - CEUPS"))
			return 30;
		if (Nombre.equals("Laboratorio 10"))
			return 31;
		if (Nombre.equals("Laboratorio 11 - UPG"))
			return 32;
		return 0;
	}

	/********************** FIN MODIFICACION GPA-03 **********************/
	/**********************INICIA MODIFICACION: EPA-01**********************/
    public void obtenerNombrePeridoActual(){
    	fechaInicioP=	stringAFecha(periodoActual.getFechaInicio());
		fechaFinP	=	stringAFecha(periodoActual.getFechaFin());
		Date date = new  Date();
		GregorianCalendar fechaIniciaPerido = new GregorianCalendar();
		GregorianCalendar fechaFinPeriodo = new GregorianCalendar();
		GregorianCalendar fechaActual = new GregorianCalendar();
		fechaIniciaPerido.setTime(fechaInicioP);
		fechaFinPeriodo.setTime(fechaFinP);
		fechaActual.setTime(date);
			if((fechaIniciaPerido.compareTo(fechaActual)<=0)&&(fechaActual.compareTo(fechaFinPeriodo)<=0))
				nombrePeriodoActual=periodoActual.getNombre();
			else
				nombrePeriodoActual=" Fuera de Periodo Regular ";
		}
    /**********************TERMINA MODIFICACION: EPA-01**********************/
	
	public Date horarioAFecha(String s) {
		Date date = null;
		SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");

		try {

			date = formatter.parse(s);

		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	public Date stringAFecha(String s) {
		Date date = null;
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");

		try {

			date = formatter.parse(s);

		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	public void llenarLunes(Date fechaAux) {
		int dia, mes, año;
		String Fecha, StringAux1, StringAux2;
		dia = fechaAux.getDate();
		mes = fechaAux.getMonth();
		mes++;
		año = fechaAux.getYear();
		año = año + 1900;
		if (mes <= 9) {
			Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
		} else {
			Fecha = "" + dia + "-" + mes + "-" + año + "";
		}
		if (dia <= 9) {
			Fecha = "0" + Fecha;
		}
		List<RegistroHorario> SLaux = listaLunes;
		Iterator<RegistroHorario> iterador = SLaux.iterator();
		while (iterador.hasNext()) {
			RegistroHorario rh = (RegistroHorario) iterador.next();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			StringAux1 = StringAux1 + " " + rh.gethInicio().getHours() + ":";
			if (rh.gethInicio().getMinutes() <= 9) {
				StringAux1 = StringAux1 + "0" + rh.gethInicio().getMinutes()
						+ ":" + "00";
			} else {
				StringAux1 = StringAux1 + rh.gethInicio().getMinutes() + ":"
						+ "00";
			}
			StringAux2 = StringAux2 + " " + rh.gethFin().getHours() + ":";
			if (rh.gethFin().getMinutes() <= 9) {
				StringAux2 = StringAux2 + "0" + rh.gethFin().getMinutes() + ":"
						+ "00";
			} else {
				StringAux2 = StringAux2 + rh.gethFin().getMinutes() + ":"
						+ "00";
			}
			switch (rh.getIdAula()) {
			case 22:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel1.addEvent(eventNuevo);
				break;
			case 23:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel2.addEvent(eventNuevo);
				break;
			case 24:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel3.addEvent(eventNuevo);
				break;
			case 25:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel4.addEvent(eventNuevo);
				break;
			case 26:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel5.addEvent(eventNuevo);
				break;
			case 27:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel6.addEvent(eventNuevo);
				break;
			case 28:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel7.addEvent(eventNuevo);
				break;
			case 29:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel8.addEvent(eventNuevo);
				break;
			case 30:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel9.addEvent(eventNuevo);
				break;
			case 31:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelA.addEvent(eventNuevo);
				break;
			case 32:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelB.addEvent(eventNuevo);
				break;
			case 0:
				break;
			}
		}

	}

	public void llenarMartes(Date fechaAux) {
		int dia, mes, año;
		String Fecha, StringAux1, StringAux2;
		dia = fechaAux.getDate();
		mes = fechaAux.getMonth();
		mes++;
		año = fechaAux.getYear();
		año = año + 1900;
		if (mes <= 9) {
			Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
		} else {
			Fecha = "" + dia + "-" + mes + "-" + año + "";
		}
		if (dia <= 9) {
			Fecha = "0" + Fecha;
		}
		List<RegistroHorario> SLaux = listaMartes;
		Iterator<RegistroHorario> iterador = SLaux.iterator();
		while (iterador.hasNext()) {
			RegistroHorario rh = (RegistroHorario) iterador.next();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			StringAux1 = StringAux1 + " " + rh.gethInicio().getHours() + ":";
			if (rh.gethInicio().getMinutes() <= 9) {
				StringAux1 = StringAux1 + "0" + rh.gethInicio().getMinutes()
						+ ":" + "00";
			} else {
				StringAux1 = StringAux1 + rh.gethInicio().getMinutes() + ":"
						+ "00";
			}
			StringAux2 = StringAux2 + " " + rh.gethFin().getHours() + ":";
			if (rh.gethFin().getMinutes() <= 9) {
				StringAux2 = StringAux2 + "0" + rh.gethFin().getMinutes() + ":"
						+ "00";
			} else {
				StringAux2 = StringAux2 + rh.gethFin().getMinutes() + ":"
						+ "00";
			}
			switch (rh.getIdAula()) {
			case 22:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel1.addEvent(eventNuevo);
				break;
			case 23:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel2.addEvent(eventNuevo);
				break;
			case 24:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel3.addEvent(eventNuevo);
				break;
			case 25:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel4.addEvent(eventNuevo);
				break;
			case 26:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel5.addEvent(eventNuevo);
				break;
			case 27:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel6.addEvent(eventNuevo);
				break;
			case 28:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel7.addEvent(eventNuevo);
				break;
			case 29:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel8.addEvent(eventNuevo);
				break;
			case 30:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel9.addEvent(eventNuevo);
				break;
			case 31:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelA.addEvent(eventNuevo);
				break;
			case 32:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelB.addEvent(eventNuevo);
				break;
			case 0:
				break;
			}
		}
	}

	public void llenarMiercoles(Date fechaAux) {
		int dia, mes, año;
		String Fecha, StringAux1, StringAux2;
		dia = fechaAux.getDate();
		mes = fechaAux.getMonth();
		mes++;
		año = fechaAux.getYear();
		año = año + 1900;
		if (mes <= 9) {
			Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
		} else {
			Fecha = "" + dia + "-" + mes + "-" + año + "";
		}
		if (dia <= 9) {
			Fecha = "0" + Fecha;
		}
		List<RegistroHorario> SLaux = listaMiercoles;
		Iterator<RegistroHorario> iterador = SLaux.iterator();
		while (iterador.hasNext()) {
			RegistroHorario rh = (RegistroHorario) iterador.next();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			StringAux1 = StringAux1 + " " + rh.gethInicio().getHours() + ":";
			if (rh.gethInicio().getMinutes() <= 9) {
				StringAux1 = StringAux1 + "0" + rh.gethInicio().getMinutes()
						+ ":" + "00";
			} else {
				StringAux1 = StringAux1 + rh.gethInicio().getMinutes() + ":"
						+ "00";
			}
			StringAux2 = StringAux2 + " " + rh.gethFin().getHours() + ":";
			if (rh.gethFin().getMinutes() <= 9) {
				StringAux2 = StringAux2 + "0" + rh.gethFin().getMinutes() + ":"
						+ "00";
			} else {
				StringAux2 = StringAux2 + rh.gethFin().getMinutes() + ":"
						+ "00";
			}
			switch (rh.getIdAula()) {
			case 22:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel1.addEvent(eventNuevo);
				break;
			case 23:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel2.addEvent(eventNuevo);
				break;
			case 24:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel3.addEvent(eventNuevo);
				break;
			case 25:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel4.addEvent(eventNuevo);
				break;
			case 26:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel5.addEvent(eventNuevo);
				break;
			case 27:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel6.addEvent(eventNuevo);
				break;
			case 28:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel7.addEvent(eventNuevo);
				break;
			case 29:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel8.addEvent(eventNuevo);
				break;
			case 30:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel9.addEvent(eventNuevo);
				break;
			case 31:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelA.addEvent(eventNuevo);
				break;
			case 32:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelB.addEvent(eventNuevo);
				break;
			case 0:
				break;
			}
		}
	}

	public void llenarJueves(Date fechaAux) {
		int dia, mes, año;
		String Fecha, StringAux1, StringAux2;
		dia = fechaAux.getDate();
		mes = fechaAux.getMonth();
		mes++;
		año = fechaAux.getYear();
		año = año + 1900;
		if (mes <= 9) {
			Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
		} else {
			Fecha = "" + dia + "-" + mes + "-" + año + "";
		}
		if (dia <= 9) {
			Fecha = "0" + Fecha;
		}
		List<RegistroHorario> SLaux = listaJueves;
		Iterator<RegistroHorario> iterador = SLaux.iterator();
		while (iterador.hasNext()) {
			RegistroHorario rh = (RegistroHorario) iterador.next();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			StringAux1 = StringAux1 + " " + rh.gethInicio().getHours() + ":";
			if (rh.gethInicio().getMinutes() <= 9) {
				StringAux1 = StringAux1 + "0" + rh.gethInicio().getMinutes()
						+ ":" + "00";
			} else {
				StringAux1 = StringAux1 + rh.gethInicio().getMinutes() + ":"
						+ "00";
			}
			StringAux2 = StringAux2 + " " + rh.gethFin().getHours() + ":";
			if (rh.gethFin().getMinutes() <= 9) {
				StringAux2 = StringAux2 + "0" + rh.gethFin().getMinutes() + ":"
						+ "00";
			} else {
				StringAux2 = StringAux2 + rh.gethFin().getMinutes() + ":"
						+ "00";
			}
			switch (rh.getIdAula()) {
			case 22:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel1.addEvent(eventNuevo);
				break;
			case 23:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel2.addEvent(eventNuevo);
				break;
			case 24:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel3.addEvent(eventNuevo);
				break;
			case 25:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel4.addEvent(eventNuevo);
				break;
			case 26:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel5.addEvent(eventNuevo);
				break;
			case 27:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel6.addEvent(eventNuevo);
				break;
			case 28:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel7.addEvent(eventNuevo);
				break;
			case 29:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel8.addEvent(eventNuevo);
				break;
			case 30:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel9.addEvent(eventNuevo);
				break;
			case 31:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelA.addEvent(eventNuevo);
				break;
			case 32:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelB.addEvent(eventNuevo);
				break;
			case 0:
				break;
			}
		}
	}

	public void llenarViernes(Date fechaAux) {
		int dia, mes, año;
		String Fecha, StringAux1, StringAux2;
		dia = fechaAux.getDate();
		mes = fechaAux.getMonth();
		mes++;
		año = fechaAux.getYear();
		año = año + 1900;
		if (mes <= 9) {
			Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
		} else {
			Fecha = "" + dia + "-" + mes + "-" + año + "";
		}
		if (dia <= 9) {
			Fecha = "0" + Fecha;
		}
		List<RegistroHorario> SLaux = listaViernes;
		Iterator<RegistroHorario> iterador = SLaux.iterator();
		while (iterador.hasNext()) {
			RegistroHorario rh = (RegistroHorario) iterador.next();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			StringAux1 = StringAux1 + " " + rh.gethInicio().getHours() + ":";
			if (rh.gethInicio().getMinutes() <= 9) {
				StringAux1 = StringAux1 + "0" + rh.gethInicio().getMinutes()
						+ ":" + "00";
			} else {
				StringAux1 = StringAux1 + rh.gethInicio().getMinutes() + ":"
						+ "00";
			}
			StringAux2 = StringAux2 + " " + rh.gethFin().getHours() + ":";
			if (rh.gethFin().getMinutes() <= 9) {
				StringAux2 = StringAux2 + "0" + rh.gethFin().getMinutes() + ":"
						+ "00";
			} else {
				StringAux2 = StringAux2 + rh.gethFin().getMinutes() + ":"
						+ "00";
			}
			switch (rh.getIdAula()) {
			case 22:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel1.addEvent(eventNuevo);
				break;
			case 23:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel2.addEvent(eventNuevo);
				break;
			case 24:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel3.addEvent(eventNuevo);
				break;
			case 25:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel4.addEvent(eventNuevo);
				break;
			case 26:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel5.addEvent(eventNuevo);
				break;
			case 27:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel6.addEvent(eventNuevo);
				break;
			case 28:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel7.addEvent(eventNuevo);
				break;
			case 29:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel8.addEvent(eventNuevo);
				break;
			case 30:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel9.addEvent(eventNuevo);
				break;
			case 31:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelA.addEvent(eventNuevo);
				break;
			case 32:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelB.addEvent(eventNuevo);
				break;
			case 0:
				break;
			}
		}
	}

	public void llenarSabado(Date fechaAux) {
		int dia, mes, año;
		String Fecha, StringAux1, StringAux2;
		dia = fechaAux.getDate();
		mes = fechaAux.getMonth();
		mes++;
		año = fechaAux.getYear();
		año = año + 1900;
		if (mes <= 9) {
			Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
		} else {
			Fecha = "" + dia + "-" + mes + "-" + año + "";
		}
		if (dia <= 9) {
			Fecha = "0" + Fecha;
		}
		List<RegistroHorario> SLaux = listaSabado;
		Iterator<RegistroHorario> iterador = SLaux.iterator();
		while (iterador.hasNext()) {
			RegistroHorario rh = (RegistroHorario) iterador.next();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			StringAux1 = StringAux1 + " " + rh.gethInicio().getHours() + ":";
			if (rh.gethInicio().getMinutes() <= 9) {
				StringAux1 = StringAux1 + "0" + rh.gethInicio().getMinutes()
						+ ":" + "00";
			} else {
				StringAux1 = StringAux1 + rh.gethInicio().getMinutes() + ":"
						+ "00";
			}
			StringAux2 = StringAux2 + " " + rh.gethFin().getHours() + ":";
			if (rh.gethFin().getMinutes() <= 9) {
				StringAux2 = StringAux2 + "0" + rh.gethFin().getMinutes() + ":"
						+ "00";
			} else {
				StringAux2 = StringAux2 + rh.gethFin().getMinutes() + ":"
						+ "00";
			}
			switch (rh.getIdAula()) {
			case 22:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel1.addEvent(eventNuevo);
				break;
			case 23:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel2.addEvent(eventNuevo);
				break;
			case 24:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel3.addEvent(eventNuevo);
				break;
			case 25:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel4.addEvent(eventNuevo);
				break;
			case 26:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel5.addEvent(eventNuevo);
				break;
			case 27:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel6.addEvent(eventNuevo);
				break;
			case 28:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel7.addEvent(eventNuevo);
				break;
			case 29:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel8.addEvent(eventNuevo);
				break;
			case 30:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel9.addEvent(eventNuevo);
				break;
			case 31:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelA.addEvent(eventNuevo);
				break;
			case 32:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelB.addEvent(eventNuevo);
				break;
			case 0:
				break;
			}
		}
	}

	public void llenarDomingo(Date fechaAux) {
		int dia, mes, año;
		String Fecha, StringAux1, StringAux2;
		dia = fechaAux.getDate();
		mes = fechaAux.getMonth();
		mes++;
		año = fechaAux.getYear();
		año = año + 1900;
		if (mes <= 9) {
			Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
		} else {
			Fecha = "" + dia + "-" + mes + "-" + año + "";
		}
		if (dia <= 9) {
			Fecha = "0" + Fecha;
		}
		List<RegistroHorario> SLaux = listaDomingo;
		Iterator<RegistroHorario> iterador = SLaux.iterator();
		while (iterador.hasNext()) {
			RegistroHorario rh = (RegistroHorario) iterador.next();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			StringAux1 = StringAux1 + " " + rh.gethInicio().getHours() + ":";
			if (rh.gethInicio().getMinutes() <= 9) {
				StringAux1 = StringAux1 + "0" + rh.gethInicio().getMinutes()
						+ ":" + "00";
			} else {
				StringAux1 = StringAux1 + rh.gethInicio().getMinutes() + ":"
						+ "00";
			}
			StringAux2 = StringAux2 + " " + rh.gethFin().getHours() + ":";
			if (rh.gethFin().getMinutes() <= 9) {
				StringAux2 = StringAux2 + "0" + rh.gethFin().getMinutes() + ":"
						+ "00";
			} else {
				StringAux2 = StringAux2 + rh.gethFin().getMinutes() + ":"
						+ "00";
			}
			switch (rh.getIdAula()) {
			case 22:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel1.addEvent(eventNuevo);
				break;
			case 23:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel2.addEvent(eventNuevo);
				break;
			case 24:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel3.addEvent(eventNuevo);
				break;
			case 25:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel4.addEvent(eventNuevo);
				break;
			case 26:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel5.addEvent(eventNuevo);
				break;
			case 27:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel6.addEvent(eventNuevo);
				break;
			case 28:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel7.addEvent(eventNuevo);
				break;
			case 29:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel8.addEvent(eventNuevo);
				break;
			case 30:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModel9.addEvent(eventNuevo);
				break;
			case 31:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelA.addEvent(eventNuevo);
				break;
			case 32:
				eventNuevo = new DefaultScheduleEvent(rh.getCurso(),
						horarioAFecha(StringAux1), horarioAFecha(StringAux2),
						rh);
				eventNuevo.setStyleClass("clase");
				eventModelB.addEvent(eventNuevo);
				break;
			case 0:
				break;
			}
		}
	}

	public void obtenerListaDeDias() {
		listaLunes = asignarAulas.obtenerLunes();
		listaMartes = asignarAulas.obtenerMartes();
		listaMiercoles = asignarAulas.obtenerMiercoles();
		listaJueves = asignarAulas.obtenerJueves();
		listaViernes = asignarAulas.obtenerViernes();
		listaSabado = asignarAulas.obtenerSabado();
		listaDomingo = asignarAulas.obtenerDomingo();
	}

	public void llenarScheduleLabos() {
		periodoActual = periodoRepository.obtenerUltimoPeriodo();
		fechaInicioP = stringAFecha(periodoActual.getFechaInicio());
		fechaFinP = stringAFecha(periodoActual.getFechaFin());
		int contador = 0;
		GregorianCalendar gcal = new GregorianCalendar();
		gcal.setTime(fechaInicioP);
		obtenerListaDeDias();
		while (gcal.getTime().compareTo(fechaFinP) <= 0) {
			fechaAux = gcal.getTime();
			switch (fechaAux.getDay()) {
			case 1:
				llenarLunes(fechaAux);
				break;
			case 2:
				llenarMartes(fechaAux);
				break;
			case 3:
				llenarMiercoles(fechaAux);
				break;
			case 4:
				llenarJueves(fechaAux);
				break;
			case 5:
				llenarViernes(fechaAux);
				break;
			case 6:
				llenarSabado(fechaAux);
				break;
			case 0:
				llenarDomingo(fechaAux);
				break;
			}
			contador++;
			gcal.add(Calendar.DAY_OF_YEAR, 1);
		}

	}

	public void llenarScheduleEventos() {
		Date d1, d2;
		int i;
		EventosAprobadosLabo = peticionService.obtenerLabosAprobados();
		int repitencias;
		Iterator<Peticion> iterador = EventosAprobadosLabo.iterator();
		GregorianCalendar gcal1 = new GregorianCalendar();
		GregorianCalendar gcal2 = new GregorianCalendar();
		while (iterador.hasNext()) {
			TipoE = "";
			Peticion paux = (Peticion) iterador.next();
			if (paux.getTipoEvento() == 1) {
				TipoE = "evento";
			} else {
				if (paux.getTipoEvento() == 2) {
					TipoE = "ceups";
				} else {
					if (paux.getTipoEvento() == 3) {
						TipoE = "upg";
					}
				}
			}
			int dia, mes, año, horaI, minutoI, segundoI, horaF, segundoF, minutoF;
			String Fecha, StringAux1, StringAux2;
			dia = paux.getDia().getDate();
			// dia=fechaAux.getDate();
			mes = paux.getDia().getMonth();
			// mes=fechaAux.getMonth();
			mes++;
			año = paux.getDia().getYear();
			// año=fechaAux.getYear();
			año = año + 1900;
			horaI = paux.gethInicio().getHours();
			minutoI = paux.gethInicio().getMinutes();
			segundoI = paux.gethInicio().getSeconds();
			horaF = paux.gethFin().getHours();
			minutoF = paux.gethFin().getMinutes();
			segundoF = paux.gethFin().getSeconds();
			if (mes <= 9) {
				Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
			} else {
				Fecha = "" + dia + "-" + mes + "-" + año + "";
			}
			if (dia <= 9) {
				Fecha = "0" + Fecha;
			}
			repitencias = paux.getNumRep();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			if (horaI <= 9) {
				StringAux1 = StringAux1 + " 0" + horaI;
			} else {
				StringAux1 = StringAux1 + " " + horaI;
			}
			if (minutoI <= 9) {
				StringAux1 = StringAux1 + ":0" + minutoI;
			} else {
				StringAux1 = StringAux1 + ":" + minutoI;
			}
			if (segundoI <= 9) {
				StringAux1 = StringAux1 + ":0" + segundoI;
			} else {
				StringAux1 = StringAux1 + ":" + segundoI;
			}
			if (horaF <= 9) {
				StringAux2 = StringAux2 + " 0" + horaF;
			} else {
				StringAux2 = StringAux2 + " " + horaF;
			}
			if (minutoF <= 9) {
				StringAux2 = StringAux2 + ":0" + minutoF;
			} else {
				StringAux2 = StringAux2 + ":" + minutoF;
			}
			if (segundoF <= 9) {
				StringAux2 = StringAux2 + ":0" + segundoF;
			} else {
				StringAux2 = StringAux2 + ":" + segundoF;
			}
			gcal1.setTime(horarioAFecha(StringAux1));
			gcal2.setTime(horarioAFecha(StringAux2));
			for (i = repitencias; i > 0; i--) {
				Fecha = "";
				switch (paux.getIdAulaPet()) {
				case 22:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel1.addEvent(eventNuevo);
					break;
				case 23:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel2.addEvent(eventNuevo);
					break;
				case 24:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel3.addEvent(eventNuevo);
					break;
				case 25:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel4.addEvent(eventNuevo);
					break;
				case 26:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel5.addEvent(eventNuevo);
					break;
				case 27:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel6.addEvent(eventNuevo);
					break;
				case 28:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel7.addEvent(eventNuevo);
					break;
				case 29:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel8.addEvent(eventNuevo);
					break;
				case 30:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModel9.addEvent(eventNuevo);
					break;
				case 31:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModelA.addEvent(eventNuevo);
					break;
				case 32:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass(TipoE);
					eventModelB.addEvent(eventNuevo);
					break;
				case 0:
					break;
				}
				gcal1.add(Calendar.DAY_OF_YEAR, 7);
				gcal2.add(Calendar.DAY_OF_MONTH, 7);
				d1 = gcal1.getTime();
				d2 = gcal2.getTime();
				dia = d1.getDate();
				// dia=fechaAux.getDate();
				mes = d1.getMonth();
				// mes=fechaAux.getMonth();
				mes++;
				año = d1.getYear();
				// año=fechaAux.getYear();
				año = año + 1900;
				horaI = d1.getHours();
				minutoI = d1.getMinutes();
				segundoI = d1.getSeconds();
				horaF = d2.getHours();
				minutoF = d2.getMinutes();
				segundoF = d2.getSeconds();
				if (mes <= 9) {
					Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
				} else {
					Fecha = "" + dia + "-" + mes + "-" + año + "";
				}
				if (dia <= 9) {
					Fecha = "0" + Fecha;
				}
				StringAux1 = Fecha;
				StringAux2 = Fecha;
				if (horaI <= 9) {
					StringAux1 = StringAux1 + " 0" + horaI;
				} else {
					StringAux1 = StringAux1 + " " + horaI;
				}
				if (minutoI <= 9) {
					StringAux1 = StringAux1 + ":0" + minutoI;
				} else {
					StringAux1 = StringAux1 + ":" + minutoI;
				}
				if (segundoI <= 9) {
					StringAux1 = StringAux1 + ":0" + segundoI;
				} else {
					StringAux1 = StringAux1 + ":" + segundoI;
				}
				if (horaF <= 9) {
					StringAux2 = StringAux2 + " 0" + horaF;
				} else {
					StringAux2 = StringAux2 + " " + horaF;
				}
				if (minutoF <= 9) {
					StringAux2 = StringAux2 + ":0" + minutoF;
				} else {
					StringAux2 = StringAux2 + ":" + minutoF;
				}
				if (segundoF <= 9) {
					StringAux2 = StringAux2 + ":0" + segundoF;
				} else {
					StringAux2 = StringAux2 + ":" + segundoF;
				}
			}
		}
		TipoE = "";

	}

	public void llenarEventosPendientes() {
		Date d1, d2;
		int i;
		pendientes = peticionService.obtenerLabosPendientes();
		int repitencias;
		Iterator<Peticion> iterador = pendientes.iterator();
		GregorianCalendar gcal1 = new GregorianCalendar();
		GregorianCalendar gcal2 = new GregorianCalendar();
		while (iterador.hasNext()) {
			Peticion paux = (Peticion) iterador.next();
			int dia, mes, año, horaI, minutoI, segundoI, horaF, segundoF, minutoF;
			String Fecha, StringAux1, StringAux2;
			dia = paux.getDia().getDate();
			// dia=fechaAux.getDate();
			mes = paux.getDia().getMonth();
			// mes=fechaAux.getMonth();
			mes++;
			año = paux.getDia().getYear();
			// año=fechaAux.getYear();
			año = año + 1900;
			horaI = paux.gethInicio().getHours();
			minutoI = paux.gethInicio().getMinutes();
			segundoI = paux.gethInicio().getSeconds();
			horaF = paux.gethFin().getHours();
			minutoF = paux.gethFin().getMinutes();
			segundoF = paux.gethFin().getSeconds();
			if (mes <= 9) {
				Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
			} else {
				Fecha = "" + dia + "-" + mes + "-" + año + "";
			}
			if (dia <= 9) {
				Fecha = "0" + Fecha;
			}
			repitencias = paux.getNumRep();
			StringAux1 = Fecha;
			StringAux2 = Fecha;
			if (horaI <= 9) {
				StringAux1 = StringAux1 + " 0" + horaI;
			} else {
				StringAux1 = StringAux1 + " " + horaI;
			}
			if (minutoI <= 9) {
				StringAux1 = StringAux1 + ":0" + minutoI;
			} else {
				StringAux1 = StringAux1 + ":" + minutoI;
			}
			if (segundoI <= 9) {
				StringAux1 = StringAux1 + ":0" + segundoI;
			} else {
				StringAux1 = StringAux1 + ":" + segundoI;
			}
			if (horaF <= 9) {
				StringAux2 = StringAux2 + " 0" + horaF;
			} else {
				StringAux2 = StringAux2 + " " + horaF;
			}
			if (minutoF <= 9) {
				StringAux2 = StringAux2 + ":0" + minutoF;
			} else {
				StringAux2 = StringAux2 + ":" + minutoF;
			}
			if (segundoF <= 9) {
				StringAux2 = StringAux2 + ":0" + segundoF;
			} else {
				StringAux2 = StringAux2 + ":" + segundoF;
			}
			gcal1.setTime(horarioAFecha(StringAux1));
			gcal2.setTime(horarioAFecha(StringAux2));
			for (i = repitencias; i > 0; i--) {
				Fecha = "";
				switch (paux.getIdAulaPet()) {
				case 22:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel1.addEvent(eventNuevo);
					break;
				case 23:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel2.addEvent(eventNuevo);
					break;
				case 24:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel3.addEvent(eventNuevo);
					break;
				case 25:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel4.addEvent(eventNuevo);
					break;
				case 26:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel5.addEvent(eventNuevo);
					break;
				case 27:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel6.addEvent(eventNuevo);
					break;
				case 28:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel7.addEvent(eventNuevo);
					break;
				case 29:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel8.addEvent(eventNuevo);
					break;
				case 30:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModel9.addEvent(eventNuevo);
					break;
				case 31:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModelA.addEvent(eventNuevo);
					break;
				case 32:
					eventNuevo = new DefaultScheduleEvent(
							paux.getNombreEvento(), horarioAFecha(StringAux1),
							horarioAFecha(StringAux2), paux);
					eventNuevo.setStyleClass("pendiente");
					eventModelB.addEvent(eventNuevo);
					break;
				case 0:
					break;
				}
				gcal1.add(Calendar.DAY_OF_YEAR, 7);
				gcal2.add(Calendar.DAY_OF_MONTH, 7);
				d1 = gcal1.getTime();
				d2 = gcal2.getTime();
				dia = d1.getDate();
				// dia=fechaAux.getDate();
				mes = d1.getMonth();
				// mes=fechaAux.getMonth();
				mes++;
				año = d1.getYear();
				// año=fechaAux.getYear();
				año = año + 1900;
				horaI = d1.getHours();
				minutoI = d1.getMinutes();
				segundoI = d1.getSeconds();
				horaF = d2.getHours();
				minutoF = d2.getMinutes();
				segundoF = d2.getSeconds();
				if (mes <= 9) {
					Fecha = "" + dia + "-" + "0" + mes + "-" + año + "";
				} else {
					Fecha = "" + dia + "-" + mes + "-" + año + "";
				}
				if (dia <= 9) {
					Fecha = "0" + Fecha;
				}
				StringAux1 = Fecha;
				StringAux2 = Fecha;
				if (horaI <= 9) {
					StringAux1 = StringAux1 + " 0" + horaI;
				} else {
					StringAux1 = StringAux1 + " " + horaI;
				}
				if (minutoI <= 9) {
					StringAux1 = StringAux1 + ":0" + minutoI;
				} else {
					StringAux1 = StringAux1 + ":" + minutoI;
				}
				if (segundoI <= 9) {
					StringAux1 = StringAux1 + ":0" + segundoI;
				} else {
					StringAux1 = StringAux1 + ":" + segundoI;
				}
				if (horaF <= 9) {
					StringAux2 = StringAux2 + " 0" + horaF;
				} else {
					StringAux2 = StringAux2 + " " + horaF;
				}
				if (minutoF <= 9) {
					StringAux2 = StringAux2 + ":0" + minutoF;
				} else {
					StringAux2 = StringAux2 + ":" + minutoF;
				}
				if (segundoF <= 9) {
					StringAux2 = StringAux2 + ":0" + segundoF;
				} else {
					StringAux2 = StringAux2 + ":" + segundoF;
				}
			}
		}

	}

	public void llenarLaboratorios() {
		this.listaLaboratorios = asignarListaLaboratorios
				.obtenerListaLaboratorios();
	}

	public void verificarCrucePeticiones() {
		error.clear();
		CrucePet.clear();
		boolean salir = false;
		int i, repitenciasSelected, repitenciasPaux;
		this.posibleCrucePet = peticionService.obtenerListaPosibleCrucePet(
				peticionSelected.getIdPeticion(),
				peticionSelected.getIdAulaPet(), peticionSelected.gethInicio(),
				peticionSelected.gethFin(), peticionSelected.getNumDiaSemana());
		if (posibleCrucePet.isEmpty()) {
			setExisteCrucePet(false);
			System.out
					.println("NO EXISTE CRUCE DE PETICIONES PENDIENTES PARA EL SELECCIONADO");
		} else {
			System.out
					.println("SI EXISTE POSIBLE CRUCE DE PETICIONES PENDIENTES PARA EL SELECCIONADO");
			Iterator<Peticion> iterador = posibleCrucePet.iterator();
			GregorianCalendar inicioPaux = new GregorianCalendar();
			GregorianCalendar finPaux = new GregorianCalendar();
			GregorianCalendar inicioSelected = new GregorianCalendar();
			GregorianCalendar finSelected = new GregorianCalendar();
			GregorianCalendar selectedIterativo = new GregorianCalendar();
			while (iterador.hasNext()) {
				Peticion paux = (Peticion) iterador.next();
				inicioSelected.setTime(peticionSelected.getDia());// inicioEventoSeleccionado
				finSelected.setTime(peticionSelected.getDia());// finEventoSeleccionado
				selectedIterativo.setTime(peticionSelected.getDia());// finEventoSeleccionado
				inicioPaux.setTime(paux.getDia());// inicioPaux
				finPaux.setTime(paux.getDia());// finPaux
				finPaux.add(Calendar.DAY_OF_YEAR, (7 * (paux.getNumRep()-1)));
				if (inicioSelected.after(finPaux)) {
					System.out
							.println("EL EVENTO SELECTED EMPIEZA LUEGO DEL TERMINO DE "
									+ paux.getNombreEvento());
				} else {
					finSelected.add(Calendar.DAY_OF_YEAR,
							(7 * (peticionSelected.getNumRep()-1)));// fin de evento
																// Seleccionado
					if (finSelected.before(inicioPaux)) {
						System.out
								.println("EL EVENTO SELECTED EMPIEZA ANTES DEL INICIO DE "
										+ paux.getNombreEvento());
					} else {
						if (inicioSelected.equals(inicioPaux)
								|| inicioSelected.equals(finPaux)
								|| finSelected.equals(finPaux)
								|| finSelected.equals(inicioPaux)) {
							System.out
									.println("EL EVENTO SELECTED EMPIEZA y/o TERMINA EN LAS MISMAS FECHAS DE "
											+ paux.getNombreEvento());
							// añadir paux a la lista de errores
							CrucePet.add(paux);
							error.add(paux.getNombreEvento() + ", Aula : "
									+ paux.getNombreAula() + ", Hora Inicio : "
									+ (paux.gethInicio().getHours()) + ":"
									+ (paux.gethInicio().getMinutes()) + ":"
									+ (paux.gethInicio().getSeconds())
									+ ", Hora Fin : "
									+ (paux.gethFin().getHours()) + ":"
									+ (paux.gethFin().getMinutes()) + ":"
									+ (paux.gethFin().getSeconds()));
						} else {
							repitenciasSelected = peticionSelected.getNumRep();
							salir = false;
							while (repitenciasSelected > 0 && salir == false) {
								if ((selectedIterativo.compareTo(inicioPaux) > 0)
										&& (selectedIterativo
												.compareTo(finPaux) < 0)) {
									repitenciasSelected--;
									error.add(paux.getNombreEvento()
											+ ", Aula : "
											+ paux.getNombreAula()
											+ ", Hora Inicio : "
											+ (paux.gethInicio().getHours())
											+ ":"
											+ (paux.gethInicio().getMinutes())
											+ ":"
											+ (paux.gethInicio().getSeconds())
											+ ", Hora Fin : "
											+ (paux.gethFin().getHours()) + ":"
											+ (paux.gethFin().getMinutes())
											+ ":"
											+ (paux.gethFin().getSeconds()));
									CrucePet.add(paux);
									salir = true;
									System.out
											.println("EL EVENTO SELECTED TOMA LUGAR ENTRE EL PAUX "
													+ paux.getNombreEvento());
								}
								selectedIterativo.add(Calendar.DAY_OF_YEAR, 7);
							}
						}
					}
				}
			}
			if (error.isEmpty()) {
				setExisteCrucePet(false);
				System.out
						.println("NO HAY CRUCE DE PETICIONES, LISTA DE ERRORES ESTA VACIA");
				setCruPet(0);
			} else {
				setExisteCrucePet(true);
				System.out
						.println("SI HAY CRUCE DE PETICIONES, LA LISTA DE ERRORES ESTA CON ALGO ADENTRO");
				setCruPet(1);
			}
		}

	}

	public void evaluacionPeticion() {
		setCruPet(0);
		actualizarVisto();
		verificarCrucePeticiones();
	}

	public void verificarCruces() {
		error.clear();
		System.out.println("Entraste a el verificar cruce");
		verificarCruceClases();
		verificarCruceEventos();
		if (existeCruceClases) {
			System.out.println("BOOLEAN DE CRUCE CLASES EN TRUE");
		} else {
			System.out.println("BOOLEAN DE CRUCE CLASES EN FALSE");
		}
		if (existeCruceEventos) {
			System.out.println("BOOLEAN DE CRUCE Evento EN TRUE");
		} else {
			System.out.println("BOOLEAN DE CRUCE Evento EN FALSE");
		}
		if (existeCruceClases == true || existeCruceEventos == true) {
			setExisteCruce(true);
		} else {
			setExisteCruce(false);
		}
		if (existeCruce == false) {
			aceptarEvento();
			System.out.println("NO HAY CRUCES CON CLASES O EVENTOS APROBADOS");
			setExCruce(0);
		} else {
			System.out
					.println("EXISTEN CRUCES CON CLASES O EVENTOS APROBADOS FUCCKER");
			rechazarEvento();
			setExCruce(1);
		}
		enviarCorreo();
	}

	public void verificarCruceClases() {
		System.out.println("verificando cruce clases");
		int repeticiones;
		boolean salir = false;
		if (peticionSelected.getNumDiaSemana() == 0) {
			peticionSelected.setNumDiaSemana(7);
		}
		listaCruceHorarios = peticionService.obtenerCruceHorarios(
				peticionSelected.gethInicio(), peticionSelected.gethFin(),
				peticionSelected.getNumDiaSemana(),
				peticionSelected.getIdAulaPet());
		List<RegistroHorario> laux = listaCruceHorarios;
		if (peticionSelected.getNumDiaSemana() == 7) {
			peticionSelected.setNumDiaSemana(0);
		}
		if (laux.isEmpty()) {
			System.out.println("LA LISTA DE CRUCE DE CLASES ESTA VACIA");
			setExisteCruceClases(false);
		} else {
			System.out
					.println("LA LISTA DE CRUCE DE CLASES TIENE ALGO ADENTRO");
			fechaInicioP = stringAFecha(periodoActual.getFechaInicio());
			fechaFinP = stringAFecha(periodoActual.getFechaFin());

			GregorianCalendar gcalps = new GregorianCalendar();
			GregorianCalendar gcalip = new GregorianCalendar();
			GregorianCalendar gcalfp = new GregorianCalendar();
			GregorianCalendar gcalaux = new GregorianCalendar();
			gcalip.setTime(fechaInicioP);
			gcalfp.setTime(fechaFinP);
			gcalps.setTime(peticionSelected.getDia());
			repeticiones = peticionSelected.getNumRep();
			while (repeticiones > 0 && salir == false) {
				if ((gcalps.compareTo(gcalip) >= 0)
						&& (gcalps.compareTo(gcalfp) <= 0)) {
					setExisteCruceClases(true);
					salir = true;
					System.out.println("EXISTE CRUCE CON CLASE");
				}
				gcalps.add(Calendar.DAY_OF_YEAR, 7);
				repeticiones--;
			}
		}
		if (existeCruceClases == true) {
			System.out.println("EXISTE CRUCE CLASES REVISADO PAL FEIS");
			Iterator<RegistroHorario> iterador = laux.iterator();
			while (iterador.hasNext()) {
				RegistroHorario rh = (RegistroHorario) iterador.next();
				error2.add(rh.getCurso());
			}
		}
	}

	public void verificarCruceEventos() {
		System.out.println("verificando cruce eventos");
		boolean salir = false;
		int i, repitenciasSelected, repitenciasPaux;
		this.posibleCrucePetAprob = peticionService
				.obtenerListaPosibleCrucePetAprob(
						peticionSelected.getIdPeticion(),
						peticionSelected.getIdAulaPet(),
						peticionSelected.gethInicio(),
						peticionSelected.gethFin(),
						peticionSelected.getNumDiaSemana());
		List<Peticion> laux = posibleCrucePetAprob;
		if (posibleCrucePetAprob.isEmpty()) {
			setExisteCruceEventos(false);
			System.out.println("NO EXISTE CRUCE DE EVENTOS APROBADOS");
		} else {
			System.out
					.println("SI EXISTE CRUCE CON EVENTOS APROBADOS , HAY ALGO EN LA LISTA");
			Iterator<Peticion> iterador = posibleCrucePetAprob.iterator();
			GregorianCalendar inicioPaux = new GregorianCalendar();
			GregorianCalendar finPaux = new GregorianCalendar();
			GregorianCalendar inicioSelected = new GregorianCalendar();
			GregorianCalendar finSelected = new GregorianCalendar();
			GregorianCalendar selectedIterativo = new GregorianCalendar();
			while (iterador.hasNext()) {
				Peticion paux = (Peticion) iterador.next();
				inicioSelected.setTime(peticionSelected.getDia());// inicioEventoSeleccionado
				finSelected.setTime(peticionSelected.getDia());// finEventoSeleccionado
				selectedIterativo.setTime(peticionSelected.getDia());// finEventoSeleccionado
				inicioPaux.setTime(paux.getDia());// inicioPaux
				finPaux.setTime(paux.getDia());// finPaux
				finPaux.add(Calendar.DAY_OF_YEAR, (7 * (paux.getNumRep()-1)));
				if (inicioSelected.after(finPaux)) {
					System.out
							.println("EL EVENTO A SUBIR EMPIEZA LUEGO DEL TERMINO DE "
									+ paux.getNombreEvento());
				} else {
					finSelected.add(Calendar.DAY_OF_YEAR,
							(7 * (peticionSelected.getNumRep()-1)));// fin de evento
																// Seleccionado
					if (finSelected.before(inicioPaux)) {
						System.out
								.println("EL EVENTO A SUBIR EMPIEZA ANTES DEL INICIO DE "
										+ paux.getNombreEvento());
					} else {
						if (inicioSelected.equals(inicioPaux)
								|| inicioSelected.equals(finPaux)
								|| finSelected.equals(finPaux)
								|| finSelected.equals(inicioPaux)) {
							System.out
									.println("EL EVENTO A SUBIR EMPIEZA y/o TERMINA EN LAS MISMAS FECHAS DE "
											+ paux.getNombreEvento());
							// añadir paux a la lista de errores
							error2.add(paux.getNombreEvento());
							setExisteCruceEventos(true);
						} else {
							repitenciasSelected = peticionSelected.getNumRep();
							salir = false;
							while (repitenciasSelected > 0 && salir == false) {
								if ((selectedIterativo.compareTo(inicioPaux) > 0)
										&& (selectedIterativo
												.compareTo(finPaux) < 0)) {
									repitenciasSelected--;
									salir = true;
									error2.add(paux.getNombreEvento());
									setExisteCruceEventos(true);
									System.out
											.println("EL EVENTO A SUBIR TOMA LUGAR ENTRE EL PAUX "
													+ paux.getNombreEvento());
								}
								selectedIterativo.add(Calendar.DAY_OF_YEAR, 7);
							}
						}
					}
				}
			}
		}
	}

	public void registrarPeticion() {
		peticionDoc.setNumDiaSemana(peticionDoc.getDia().getDay());
		if (esUsuario == 1) {
			peticionDoc.setSoyUsuario(1);
			peticionDoc.setNombreUsuario("");
		} else {
			peticionDoc.setSoyUsuario(0);
		}
		peticionService.registrarPeticion(peticionDoc, usuario.getId_persona(),
				tipoEvento);
		peticionDoc.limpiar();
		notificarAdmin();
		limpiar();
		setExisteCruceClases(false);
		setExisteCruceEventos(false);
		setExisteCruce(false);
		setExisteCrucePet(false);
		llenartablapeticiones();
		llenarScheduleLabos();
		llenarEventosPendientes();
		llenarScheduleEventos();
//		FacesContext context = FacesContext.getCurrentInstance();
//		context.addMessage(
//				"messages",
//				new FacesMessage(
//						FacesMessage.SEVERITY_INFO,
//						"SU PETICION HA SIDO REGISTRADA , POR FAVOR ESPERE UNA RESPUSTA",
//						null));
	}

	public void llenartablapeticiones() {
		this.listaPeticiones = peticionService.obtenerListaPeticionesLabo();
	}

	public void actualizarVisto() {

		peticionService.marcarVisto(peticionSelected.getIdPeticion());
		llenartablapeticiones();
	}

	public void llenarMisPeticiones() {
		System.out.println("Mis Peticiones");
		this.misPeticiones = peticionService.obtenerMisPeticionesLabo(usuario
				.getId_persona());
	}

	public void aceptarEvento() {
		if (existeCrucePet == false) {
			System.out.println("NO HAY CRUCE SUCCKAAA , ADICION NORMAL");
			peticionService.marcarAceptado(peticionSelected.getIdPeticion());
		} else {
			System.out.println("SI HAY CRUCE SUCCKAAA , ADICION GRUPO");
			peticionService.marcarAceptado(peticionSelected.getIdPeticion());
			Iterator<Peticion> iterador = CrucePet.iterator();
			System.out.println("TAMAÑO DE LISTA : " + CrucePet.size());
			while (iterador.hasNext()) {
				Peticion paux = (Peticion) iterador.next();
				peticionService.marcarVisto(paux.getIdPeticion());
				peticionService.marcarRechazado(paux.getIdPeticion());
			}
		}
		limpiar();
		llenartablapeticiones();
		llenarScheduleLabos();
		llenarScheduleEventos();
		llenarEventosPendientes();
	}

	public void rechazarEvento() {
		peticionService.marcarRechazado(peticionSelected.getIdPeticion());
		setDenegadoDirecto(true);
		enviarCorreo();
		limpiar();
		llenartablapeticiones();
		llenarScheduleLabos();
		llenarEventosPendientes();
		llenarScheduleEventos();
		setExisteCruceClases(false);
		setExisteCruceEventos(false);
		setExisteCruce(false);
		setExisteCrucePet(false);

	}

	public void activarInput(){
		if(soyUsuario==true){
			this.esUsuario=1;
			this.peticionDoc.setNombreUsuario(nombreUsuario);
		}else{
			this.esUsuario=0;
			this.peticionDoc.setNombreUsuario("");
		}
		System.out.println("Es ususario: "+esUsuario);
	}

	public void crearEventoDirecto() {
		if (hayCamposVaciosAdmin()) {
			
			System.out.println("hay campos vacios");
			RequestContext.getCurrentInstance().execute("PF('validDialog').show()");
		}else if(!noHayNumerosOtraPersona){//espacio para validar formatos de texo como el correo y otras cosas
			System.out.println("hay nums otra persona");
			RequestContext.getCurrentInstance().execute("PF('validDialog').show()");
		}
		else{
			peticionDoc.setNumDiaSemana(peticionDoc.getDia().getDay());
			peticionDoc.setAlquiler(Alquiler);
			if (esUsuario == 1) {
				peticionDoc.setSoyUsuario(1);
				peticionDoc.setNombreUsuario("");
			} else {
				peticionDoc.setSoyUsuario(0);
			}
			peticionDoc.setVisto(1);
			
			verificarCrucePeticionesDirecto(); /********************************************************************/
			
			if (existeCrucePet == true) {
				System.out.println("=================================================");
				System.out.println("CHOCA CON PETICIONES");
				int n = CrucePet.size();
				System.out.println("Tamaño de vector cruces: "+n);
				for (int j = 0; j < n; j++) {
					System.out.println("Id cruce --> "+CrucePet.get(j).getIdPeticion());
					peticionService.marcarRechazado(CrucePet.get(j).getIdPeticion());
					System.out.println("Id pet rechazada --> "+CrucePet.get(j).getIdPeticion());
				}
				System.out.println("=================================================");
				CrucePet.clear();
				error.clear();
				setExisteCrucePet(false);
				setCruPet(0);
				System.out.println("TODOS ELIMINADOS. YA NO HAY CRUCE");
				
				peticionDoc.setRespuesta(1);
				peticionService.registrarPeticionDir(peticionDoc,
						usuario.getId_persona(), tipoEvento);
				RequestContext.getCurrentInstance().execute("eventDialog1.hide()");
				FacesContext context = FacesContext.getCurrentInstance();
				context.addMessage("messages", new FacesMessage(
						FacesMessage.SEVERITY_INFO,
						"SU EVENTO HA SIDO CREADO SATISFACTORIAMENTE", null));
				
				limpiar();
				setExisteCruceClases(false);
				setExisteCruceEventos(false);
				setExisteCruce(false);
				setExisteCrucePet(false);
				llenartablapeticiones();
				llenarScheduleLabos();
				llenarEventosPendientes();
				llenarScheduleEventos();
				
				RequestContext.getCurrentInstance().update("form");
				
				//RequestContext.getCurrentInstance().execute("crucePetDialog.show()");
				/*FacesContext context = FacesContext.getCurrentInstance();
				context.addMessage("messages",new FacesMessage(FacesMessage.SEVERITY_ERROR,"EXISTEN PETICIONES QUE ENTRAN EN CONFLICTO CON ESTA ACCION , POR FAVOR REVISE LAS PETICIONES ANTES DE CONTINUAR",null));*/
				
			} else {
				error.clear();
				System.out.println("Entraste a el verificar cruce DIR");
				verificarCruceClasesDir();
				verificarCruceEventosDir();
				if (existeCruceClases == true || existeCruceEventos == true) {
					setExisteCruce(true);
				} else {
					setExisteCruce(false);
				}
				if (existeCruce == false) {
					System.out.println("NO HAY CRUCES GENERALES SUCCKAAA DIR");
					peticionDoc.setRespuesta(1);
					peticionService.registrarPeticionDir(peticionDoc,
							usuario.getId_persona(), tipoEvento);
					RequestContext.getCurrentInstance().execute("eventDialog1.hide()");
					FacesContext context = FacesContext.getCurrentInstance();
					context.addMessage("messages", new FacesMessage(
							FacesMessage.SEVERITY_INFO,
							"SU EVENTO HA SIDO CREADO SATISFACTORIAMENTE", null));
					limpiar();
					setExisteCruceClases(false);
					setExisteCruceEventos(false);
					setExisteCruce(false);
					setExisteCrucePet(false);
					llenartablapeticiones();
					llenarScheduleLabos();
					llenarEventosPendientes();
					llenarScheduleEventos();
					
					RequestContext.getCurrentInstance().update("form");
				} else {
					System.out
							.println("EXISTEN CRUCES CON CLASES O EVENTOS FUCCKER");
					RequestContext.getCurrentInstance().execute("cruceDialog.show()");
					/*FacesContext context = FacesContext.getCurrentInstance();
					context.addMessage(
							"messages",
							new FacesMessage(
									FacesMessage.SEVERITY_ERROR,
									"EL EVENTO QUE DESEA CREAR GENERA CONFLICTOS CON CLASES O EVENTOS YA APROBADOS , NO SE PUEDE AGREGAR ESE EVENTO",
									null));*/
				}
			}
			
		}
		
		peticionDoc.limpiar();
		if (soyUsuario) {
			peticionDoc.setNombreUsuario(nombreUsuario);
		}
	}
	
	public void botonCancelarDialog(){
		RequestContext.getCurrentInstance().execute("eventDialog1.hide()");
		limpiarCampos();
	}
	
	private void verificarCrucePeticionesParaGuardado(){
		
	}
	
	public void verificarCrucePeticionesDirecto() {
		error.clear();
		CrucePet.clear();
		boolean salir = false;
		int i, repitenciasSelected, repitenciasPaux;
		this.posibleCrucePet = peticionService.obtenerListaPosibleCrucePetDir(
				peticionDoc.getIdAulaPet(), peticionDoc.gethInicio(),
				peticionDoc.gethFin(), peticionDoc.getNumDiaSemana());
		if (posibleCrucePet.isEmpty()) {
			setExisteCrucePet(false);
			System.out.println("NO EXISTE CRUCE DE PETICIONES");
		} else {
			Iterator<Peticion> iterador = posibleCrucePet.iterator();
			GregorianCalendar inicioPaux = new GregorianCalendar();
			GregorianCalendar finPaux = new GregorianCalendar();
			GregorianCalendar inicioSelected = new GregorianCalendar();
			GregorianCalendar finSelected = new GregorianCalendar();
			GregorianCalendar selectedIterativo = new GregorianCalendar();
			while (iterador.hasNext()) {
				Peticion paux = (Peticion) iterador.next();
				inicioSelected.setTime(peticionDoc.getDia());// inicioEventoSeleccionado
				finSelected.setTime(peticionDoc.getDia());// finEventoSeleccionado
				selectedIterativo.setTime(peticionDoc.getDia());// finEventoSeleccionado
				inicioPaux.setTime(paux.getDia());// inicioPaux
				finPaux.setTime(paux.getDia());// finPaux
				finPaux.add(Calendar.DAY_OF_YEAR, (7 * (paux.getNumRep()-1)));
				if (inicioSelected.after(finPaux)) {
					System.out
							.println("EL EVENTO SELECTED EMPIEZA LUEGO DEL TERMINO DE "
									+ paux.getNombreEvento());
				} else {
					finSelected.add(Calendar.DAY_OF_YEAR,
							(7 * (peticionDoc.getNumRep()-1)));// fin de evento
															// Seleccionado
					if (finSelected.before(inicioPaux)) {
						System.out
								.println("EL EVENTO SELECTED EMPIEZA ANTES DEL INICIO DE "
										+ paux.getNombreEvento());
					} else {
						if (inicioSelected.equals(inicioPaux)
								|| inicioSelected.equals(finPaux)
								|| finSelected.equals(finPaux)
								|| finSelected.equals(inicioPaux)) {
							System.out
									.println("EL EVENTO SELECTED EMPIEZA y/o TERMINA EN LAS MISMAS FECHAS DE "
											+ paux.getNombreEvento());
							// añadir paux a la lista de errores
							CrucePet.add(paux);
							error.add(paux.getNombreEvento() + ", Aula : "
									+ paux.getNombreAula() + ", Hora Inicio : "
									+ (paux.gethInicio().getHours()) + ":"
									+ (paux.gethInicio().getMinutes()) + ":"
									+ (paux.gethInicio().getSeconds())
									+ ", Hora Fin : "
									+ (paux.gethFin().getHours()) + ":"
									+ (paux.gethFin().getMinutes()) + ":"
									+ (paux.gethFin().getSeconds()));
						} else {
							repitenciasSelected = peticionDoc.getNumRep();
							salir = false;
							while (repitenciasSelected > 0 && salir == false) {
								if ((selectedIterativo.compareTo(inicioPaux) > 0)
										&& (selectedIterativo
												.compareTo(finPaux) < 0)) {
									repitenciasSelected--;
									error.add(paux.getNombreEvento()
											+ ", Aula : "
											+ paux.getNombreAula()
											+ ", Hora Inicio : "
											+ (paux.gethInicio().getHours())
											+ ":"
											+ (paux.gethInicio().getMinutes())
											+ ":"
											+ (paux.gethInicio().getSeconds())
											+ ", Hora Fin : "
											+ (paux.gethFin().getHours()) + ":"
											+ (paux.gethFin().getMinutes())
											+ ":"
											+ (paux.gethFin().getSeconds()));
									CrucePet.add(paux);
									salir = true;
									System.out
											.println("EL EVENTO SELECTED TOMA LUGAR ENTRE EL PAUX "
													+ paux.getNombreEvento());
								}
								selectedIterativo.add(Calendar.DAY_OF_YEAR, 7);
							}
						}
					}
				}
			}
			if (error.isEmpty()) {
				setExisteCrucePet(false);
				System.out.println("NO HAY CRUCE");
				setCruPet(0);
			} else {
				setExisteCrucePet(true);
				System.out.println("SI HAY CRUCE");
				setCruPet(1);
				
			}
		}

	}

	public void verificarCruceClasesDir() {
		int repeticiones;
		boolean salir = false;
		if (peticionDoc.getNumDiaSemana() == 0) {
			peticionDoc.setNumDiaSemana(7);
		}
		listaCruceHorarios = peticionService.obtenerCruceHorariosDir(
				peticionDoc.gethInicio(), peticionDoc.gethFin(),
				peticionDoc.getNumDiaSemana(), peticionDoc.getIdAulaPet());
		List<RegistroHorario> laux = listaCruceHorarios;
		if (peticionDoc.getNumDiaSemana() == 7) {
			peticionDoc.setNumDiaSemana(0);
		}
		if (laux.isEmpty()) {
			setExisteCruceClases(false);
		} else {
			fechaInicioP = stringAFecha(periodoActual.getFechaInicio());
			fechaFinP = stringAFecha(periodoActual.getFechaFin());

			GregorianCalendar gcalps = new GregorianCalendar();
			GregorianCalendar gcalip = new GregorianCalendar();
			GregorianCalendar gcalfp = new GregorianCalendar();
			GregorianCalendar gcalaux = new GregorianCalendar();
			gcalip.setTime(fechaInicioP);
			gcalfp.setTime(fechaFinP);
			gcalps.setTime(peticionDoc.getDia());
			repeticiones = peticionDoc.getNumRep();
			while (repeticiones > 0 && salir == false) {
				if ((gcalps.compareTo(gcalip) >= 0)
						&& (gcalps.compareTo(gcalfp) <= 0)) {
					setExisteCruceClases(true);
					salir = true;
					System.out.println("EXISTE CRUCE CON CLASE");
				}
				gcalps.add(Calendar.DAY_OF_YEAR, 7);
				repeticiones--;
			}
		}
		if (existeCruceClases == true) {
			Iterator<RegistroHorario> iterador = laux.iterator();
			while (iterador.hasNext()) {
				RegistroHorario rh = (RegistroHorario) iterador.next();
				error.add(rh.getCurso());
			}
		} else {
			System.out.println("NO HAY CRUCE CON CLASE");
		}
	}

	public void verificarCruceEventosDir() {
		boolean salir = false;
		int i, repitenciasSelected, repitenciasPaux;
		this.posibleCrucePetAprob = peticionService
				.obtenerListaPosibleCrucePetAprobDir(
						peticionDoc.getIdAulaPet(), peticionDoc.gethInicio(),
						peticionDoc.gethFin(), peticionDoc.getNumDiaSemana());
		List<Peticion> laux = posibleCrucePetAprob;
		if (posibleCrucePetAprob.isEmpty()) {
			setExisteCruceEventos(false);
			System.out.println("NO EXISTE CRUCE DE EVENTOS");
		} else {
			Iterator<Peticion> iterador = posibleCrucePetAprob.iterator();
			GregorianCalendar inicioPaux = new GregorianCalendar();
			GregorianCalendar finPaux = new GregorianCalendar();
			GregorianCalendar inicioSelected = new GregorianCalendar();
			GregorianCalendar finSelected = new GregorianCalendar();
			GregorianCalendar selectedIterativo = new GregorianCalendar();
			while (iterador.hasNext()) {
				Peticion paux = (Peticion) iterador.next();
				inicioSelected.setTime(peticionDoc.getDia());// inicioEventoSeleccionado
				finSelected.setTime(peticionDoc.getDia());// finEventoSeleccionado
				selectedIterativo.setTime(peticionDoc.getDia());// finEventoSeleccionado
				inicioPaux.setTime(paux.getDia());// inicioPaux
				finPaux.setTime(paux.getDia());// finPaux
				finPaux.add(Calendar.DAY_OF_YEAR, (7 * (paux.getNumRep()-1)));
				if (inicioSelected.after(finPaux)) {
					System.out
							.println("EL EVENTO A SUBIR EMPIEZA LUEGO DEL TERMINO DE "
									+ paux.getNombreEvento());
				} else {
					finSelected.add(Calendar.DAY_OF_YEAR,
							(7 * (peticionDoc.getNumRep()-1)));// fin de evento
															// Seleccionado
					if (finSelected.before(inicioPaux)) {
						System.out
								.println("EL EVENTO A SUBIR EMPIEZA ANTES DEL INICIO DE "
										+ paux.getNombreEvento());
					} else {
						if (inicioSelected.equals(inicioPaux)
								|| inicioSelected.equals(finPaux)
								|| finSelected.equals(finPaux)
								|| finSelected.equals(inicioPaux)) {
							System.out
									.println("EL EVENTO A SUBIR EMPIEZA y/o TERMINA EN LAS MISMAS FECHAS DE "
											+ paux.getNombreEvento());
							// añadir paux a la lista de errores
							error.add(paux.getNombreEvento());
							setExisteCruceEventos(true);
						} else {
							repitenciasSelected = peticionDoc.getNumRep();
							salir = false;
							while (repitenciasSelected > 0 && salir == false) {
								if ((selectedIterativo.compareTo(inicioPaux) > 0)
										&& (selectedIterativo
												.compareTo(finPaux) < 0)) {
									repitenciasSelected--;
									salir = true;
									error.add(paux.getNombreEvento());
									setExisteCruceEventos(true);
									System.out
											.println("EL EVENTO A SUBIR TOMA LUGAR ENTRE EL PAUX "
													+ paux.getNombreEvento());
								}
								selectedIterativo.add(Calendar.DAY_OF_YEAR, 7);
							}
						}
					}
				}
			}
		}
	}

	public void enviarCorreo() {
		if (existeCrucePet == false && denegadoDirecto == false) {
			System.out.println("ENVIANDO CORREO DE ACEPTACION");
			if (peticionSelected.getAlquiler() == 0) {
				mailer.EnviarCorreo(
						peticionSelected.getEmail(),
						"SOLICITUD DE EVENTO ACEPTADA",
						"LA PETICION DEL EVENTO : "
								+ peticionSelected.getNombreEvento()
								+ " HA SIDO ACPETADA \n\n DETALLES DEL EVENTO : \n\n NOMBRE DE EVENTO : "
								+ peticionSelected.getNombreEvento()
								+ "\n\n NOMBRE DE USUARIO DEL AMBIENTE : "
								+ peticionSelected.getNombreUsuario()
								+ "\n\n AULA : "
								+ peticionSelected.getNombreAula()
								+ "\n\n HORA INICIO : "
								+ (peticionSelected.gethInicio().getHours())
								+ ":"
								+ (peticionSelected.gethInicio().getMinutes())
								+ ":"
								+ (peticionSelected.gethInicio().getSeconds())
								+ "\n\n HORA FIN : "
								+ (peticionSelected.gethFin().getHours()) + ":"
								+ (peticionSelected.gethFin().getMinutes())
								+ ":"
								+ (peticionSelected.gethFin().getSeconds())
								+ "\n\n NUMERO DE SEMANAS DE DURACION : "
								+ peticionSelected.getNumRep());
			} else {
				mailer.EnviarCorreo(
						peticionSelected.getEmail(),
						"SOLICITUD DE EVENTO ACEPTADA",
						"LA PETICION DEL EVENTO : "
								+ peticionSelected.getNombreEvento()
								+ " HA SIDO ACPETADA \n\n DETALLES DEL EVENTO : \n\n NOMBRE DE EVENTO : "
								+ peticionSelected.getNombreEvento()
								+ "\n\n NOMBRE DE USUARIO DEL AMBIENTE : "
								+ peticionSelected.getNombreUsuario()
								+ "\n\n AULA : "
								+ peticionSelected.getNombreAula()
								+ "\n\n HORA INICIO : "
								+ (peticionSelected.gethInicio().getHours())
								+ ":"
								+ (peticionSelected.gethInicio().getMinutes())
								+ ":"
								+ (peticionSelected.gethInicio().getSeconds())
								+ "\n\n HORA FIN : "
								+ (peticionSelected.gethFin().getHours())
								+ ":"
								+ (peticionSelected.gethFin().getMinutes())
								+ ":"
								+ (peticionSelected.gethFin().getSeconds())
								+ "\n\n NUMERO DE SEMANAS DE DURACION : "
								+ peticionSelected.getNumRep()
								+ "\n\n\n DEBIDO A QUE EL EVENTO ES UN ALQUILER , POSTERIORMENTE SE LE ENVIARÁ EL COSTO DEL ALQUILER DE EL AMBIENTE");
			}

		} else {
			if (existeCrucePet == true && denegadoDirecto == false) {
				peticionService
						.marcarAceptado(peticionSelected.getIdPeticion());
				mailer.EnviarCorreo(
						peticionSelected.getEmail(),
						"SOLICITUD DE EVENTO ACEPTADA",
						"LA PETICION DEL EVENTO : "
								+ peticionSelected.getNombreEvento()
								+ " HA SIDO ACPETADA \n\n DETALLES DEL EVENTO : \n\n NOMBRE DE EVENTO : "
								+ peticionSelected.getNombreEvento()
								+ "\n\n NOMBRE DE USUARIO DEL AMBIENTE : "
								+ peticionSelected.getNombreUsuario()
								+ "\n\n AULA : "
								+ peticionSelected.getNombreAula()
								+ "\n\n HORA INICIO : "
								+ (peticionSelected.gethInicio().getHours())
								+ ":"
								+ (peticionSelected.gethInicio().getMinutes())
								+ ":"
								+ (peticionSelected.gethInicio().getSeconds())
								+ "\n\n HORA FIN : "
								+ (peticionSelected.gethFin().getHours()) + ":"
								+ (peticionSelected.gethFin().getMinutes())
								+ ":"
								+ (peticionSelected.gethFin().getSeconds())
								+ "\n\n NUMERO DE SEMANAS DE DURACION : "
								+ peticionSelected.getNumRep());
				Iterator<Peticion> iterador = CrucePet.iterator();
				while (iterador.hasNext()) {
					Peticion paux = (Peticion) iterador.next();
					peticionService.marcarVisto(paux.getIdPeticion());
					peticionService.marcarRechazado(paux.getIdPeticion());
					mailer.EnviarCorreo(
							paux.getEmail(),
							"SOLICITUD DE EVENTO RECHAZADA",
							"LA PETICION DEL EVENTO : "
									+ paux.getNombreEvento()
									+ " HA SIDO RECHAZADA \n\n DETALLES DEL EVENTO : \n\n NOMBRE DE EVENTO : "
									+ paux.getNombreEvento()
									+ "\n\n NOMBRE DE USUARIO DEL AMBIENTE : "
									+ paux.getNombreUsuario()
									+ "\n\n AULA : "
									+ paux.getNombreAula()
									+ "\n\n HORA INICIO : "
									+ (paux.gethInicio().getHours())
									+ ":"
									+ (paux.gethInicio().getMinutes())
									+ ":"
									+ (paux.gethInicio().getSeconds())
									+ "\n\n HORA FIN : "
									+ (paux.gethFin().getHours())
									+ ":"
									+ (paux.gethFin().getMinutes())
									+ ":"
									+ (paux.gethFin().getSeconds())
									+ "\n\n NUMERO DE SEMANAS DE DURACION : "
									+ paux.getNumRep()
									+ "\n\n\n PARA MAYOR INFORMACION , CONTACTE A EL ENCARGADO DE LA ADMINISTRACION DE LABORATORIO");
				}
			} else {
				if (denegadoDirecto == true) {
					System.out.println("MANDARAS DENEGACION DIRECTA");
					mailer.EnviarCorreo(
							peticionSelected.getEmail(),
							"SOLICITUD DE EVENTO RECHAZADA",
							"LA PETICION DEL EVENTO : "
									+ peticionSelected.getNombreEvento()
									+ " HA SIDO RECHAZADA \n\n DETALLES DEL EVENTO : \n\n NOMBRE DE EVENTO : "
									+ peticionSelected.getNombreEvento()
									+ "\n\n NOMBRE DE USUARIO DEL AMBIENTE : "
									+ peticionSelected.getNombreUsuario()
									+ "\n\n AULA : "
									+ peticionSelected.getNombreAula()
									+ "\n\n HORA INICIO : "
									+ (peticionSelected.gethInicio().getHours())
									+ ":"
									+ (peticionSelected.gethInicio()
											.getMinutes())
									+ ":"
									+ (peticionSelected.gethInicio()
											.getSeconds())
									+ "\n\n HORA FIN : "
									+ (peticionSelected.gethFin().getHours())
									+ ":"
									+ (peticionSelected.gethFin().getMinutes())
									+ ":"
									+ (peticionSelected.gethFin().getSeconds())
									+ "\n\n NUMERO DE SEMANAS DE DURACION : "
									+ peticionSelected.getNumRep()
									+ "\n\n\n PARA MAYOR INFORMACION , CONTACTE A EL ENCARGADO DE LA ADMINISTRACION DE LABORATORIOS");
					System.out.println("YA MANDO");
				}
			}
		}
		setExisteCruceClases(false);
		setExisteCruceEventos(false);
		setExisteCruce(false);
		setExisteCrucePet(false);
		setDenegadoDirecto(false);

	}

	public void notificarAdmin() {
		mailer.EnviarCorreo(
				emailEncargado,
				"NUEVA PETICION DE EVENTO",
				"SE HA SOLICITADO LA RESERVA DE UN LABORATORIO . POR FAVOR , REMITASE EL SISTEMA DE DISPONIBILIDAD HORARIA (sisdiam)  PARA VER LOS DETALLES DE ESTA SOLICITUD Y EVALUARLA");
	}

	public void verificarCruce() {
		/*
		 private boolean campoVacioOtraPersona;
	private boolean campoVacioNombreEvento;
	private boolean campoVacioEmail;
	private boolean campoVacioFecha;
	private boolean campoVacioHoraInicio;
	private boolean campoVacioHoraFin;
	private boolean campoVacioNumSemanas;
	private boolean campoVacioMotivo; 
		*/
		if (hayCamposVacios()) {
			RequestContext.getCurrentInstance().execute("PF('validDialog').show()");
		}else if(!campoEmailFormato || !noHayNumerosOtraPersona){//espacio para validar formatos de texo como el correo y otras cosas
			RequestContext.getCurrentInstance().execute("PF('validDialog').show()");
		} 
		else {
			error.clear();
			peticionDoc.setAlquiler(Alquiler);
			peticionDoc.setNumDiaSemana(peticionDoc.getDia().getDay());
			if (esUsuario == 1) {
				peticionDoc.setSoyUsuario(1);
				peticionDoc.setNombreUsuario(nombreUsuario);
			} else {
				peticionDoc.setSoyUsuario(0);
			}
			peticionDoc.setVisto(1);
			verificarCrucePeticionesDirecto();
			if (existeCrucePet == true) {
				System.out.println("HAY CRUCE DE PETICIONES");
			}
			error2.clear();
			verificarCruceClasesDir();
			verificarCruceEventosDir();
			if (existeCruceClases == true || existeCruceEventos == true) {
				setExisteCruce(true);
				System.out.println("HAY CRUCE DE EVENTOS O CLASES");

			} else {
				setExisteCruce(false);
			}
			
			if (existeCruce == true) {
				setCruceFinal(1);
			} else {
				if (existeCruce == false && existeCrucePet == true) {
					setCruceFinal(2);
				} else {
					setCruceFinal(3);
				}
			}
			setAulaPedida(listaLaboratorios.get((peticionDoc.getIdAulaPet() - 22))
					.getNomb());
			RequestContext.getCurrentInstance().execute("eventDialog1.hide()");
			RequestContext.getCurrentInstance().execute("conDialog.show()");

		}
		
		
	}

	public void verificarTipoEvento() {

		idCEUPS = peticionService.obtenerIdCEUPS(usuario.getId_persona());
		idUPG = peticionService.obtenerIdUPG(usuario.getId_persona());
		if (idCEUPS.isEmpty()) {
			if (idUPG.isEmpty()) {
				setTipoEvento(1);
			} else {
				setTipoEvento(3);
			}
		} else {
			setTipoEvento(2);
		}
	}

	public void validarAlquiler() {
		if (esAlquiler == true) {
			this.Alquiler = 1;
		} else {
			this.Alquiler = 0;
		}
	}

	public void revertirEvento() {
		peticionService.revertir(peticionSelected.getIdPeticion());
		limpiar();
		llenartablapeticiones();
		llenarScheduleLabos();
		llenarScheduleEventos();
		llenarEventosPendientes();
		mailer.EnviarCorreo(
				peticionSelected.getEmail(),
				"DECISION DE EVENTO REVERTIDA",
				"LA DECISION TOMADA ACERCA DEL EVENTO : "
						+ peticionSelected.getNombreEvento()
						+ " HA SIDO REVERTIDA , POR FAVOR ESPERE MIENTRA SU PETICION ES REVALUADA");
		/*listaPeticiones.clear();
		this.listaPeticiones = peticionService.obtenerListaPeticionesLabo();
		System.out.println("Termino de enviar el email. XDDDDDDDDDDD");*/
		

	}
}